10148

Build # 10148

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/be24bac235f44ffd8d555d2c5c046f66df1786eb">be24bac23<a href="https://github.com/apache/carbondata/commit/be24bac235f44ffd8d555d2c5c046f66df1786eb">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/690952c6471af09918d1194a3190261a2e48bec9">690952c64</a>">690952c64</a><a href="https://github.com/apache/carbondata/commit/be24bac235f44ffd8d555d2c5c046f66df1786eb"> into 96b2ea364">96b2ea364</a>

Run Details

61509 of 77818 relevant lines covered (79.04%)

1.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

54.39

/integration/spark-common/src/main/scala/org/apache/spark/util/CarbonReflectionUtils.scala

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.spark.util

import java.lang.reflect.Method

import scala.reflect.runtime._
import scala.reflect.runtime.universe._

import org.apache.spark.{SPARK_VERSION, SparkContext}
import org.apache.spark.rdd.RDD
import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
import org.apache.spark.sql.catalyst.{InternalRow, TableIdentifier}
import org.apache.spark.sql.catalyst.analysis.UnresolvedRelation
import org.apache.spark.sql.catalyst.catalog.CatalogTable
import org.apache.spark.sql.catalyst.expressions.{Attribute, Expression}
import org.apache.spark.sql.catalyst.parser.AstBuilder
import org.apache.spark.sql.catalyst.plans.logical.{InsertIntoTable, LogicalPlan, SubqueryAlias}
import org.apache.spark.sql.catalyst.plans.physical.Partitioning
import org.apache.spark.sql.execution.{RowDataSourceScanExec, SparkPlan}
import org.apache.spark.sql.execution.command.RunnableCommand
import org.apache.spark.sql.execution.datasources.{DataSource, LogicalRelation}
import org.apache.spark.sql.sources.{BaseRelation, Filter}
import org.apache.spark.sql.types.StructField

import org.apache.carbondata.core.constants.CarbonCommonConstants

/**
 * Reflection APIs
 */

object CarbonReflectionUtils {
  private val rm = universe.runtimeMirror(getClass.getClassLoader)

  /**
   * Returns the field val from a object through reflection.
   * @param name - name of the field being retrieved.
   * @param obj - Object from which the field has to be retrieved.
   * @tparam T
   * @return
   */
  def getField[T: TypeTag : reflect.ClassTag](name: String, obj: T): Any = {
    val im = rm.reflect(obj)
    im.symbol.typeSignature.members.find(_.name.toString.equals(name))
      .map(l => im.reflectField(l.asTerm).get).getOrElse(null)
  }

  def getUnresolvedRelation(
      tableIdentifier: TableIdentifier,
      tableAlias: Option[String] = None): UnresolvedRelation = {
    val className = "org.apache.spark.sql.catalyst.analysis.UnresolvedRelation"
    if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      createObject(
        className,
        tableIdentifier,
        tableAlias)._1.asInstanceOf[UnresolvedRelation]
    } else if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      createObject(
        className,
        tableIdentifier)._1.asInstanceOf[UnresolvedRelation]
    } else {
      throw new UnsupportedOperationException(s"Unsupported Spark version $SPARK_VERSION")
    }
  }

  def getSubqueryAlias(sparkSession: SparkSession, alias: Option[String],
      relation: LogicalPlan,
      view: Option[TableIdentifier]): SubqueryAlias = {
    val className = "org.apache.spark.sql.catalyst.plans.logical.SubqueryAlias"
    if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      createObject(
        className,
        alias.getOrElse(""),
        relation,
        Option(view))._1.asInstanceOf[SubqueryAlias]
    } else if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      createObject(
        className,
        alias.getOrElse(""),
        relation)._1.asInstanceOf[SubqueryAlias]
    } else {
      throw new UnsupportedOperationException("Unsupported Spark version")
    }
  }

  def getInsertIntoCommand(table: LogicalPlan,
      partition: Map[String, Option[String]],
      query: LogicalPlan,
      overwrite: Boolean,
      ifPartitionNotExists: Boolean): InsertIntoTable = {
    val className = "org.apache.spark.sql.catalyst.plans.logical.InsertIntoTable"
    if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      val overwriteOptions = createObject(
        "org.apache.spark.sql.catalyst.plans.logical.OverwriteOptions",
        overwrite.asInstanceOf[Object], Map.empty.asInstanceOf[Object])._1.asInstanceOf[Object]
      createObject(
        className,
        table,
        partition,
        query,
        overwriteOptions,
        ifPartitionNotExists.asInstanceOf[Object])._1.asInstanceOf[InsertIntoTable]
    } else if (SparkUtil.isSparkVersionXandAbove("2.2") ) {
      createObject(
        className,
        table,
        partition,
        query,
        overwrite.asInstanceOf[Object],
        ifPartitionNotExists.asInstanceOf[Object])._1.asInstanceOf[InsertIntoTable]
    } else {
      throw new UnsupportedOperationException("Unsupported Spark version")
    }
  }

  def getLogicalRelation(relation: BaseRelation,
      expectedOutputAttributes: Seq[Attribute],
      catalogTable: Option[CatalogTable],
      isStreaming: Boolean): LogicalRelation = {
    val className = "org.apache.spark.sql.execution.datasources.LogicalRelation"
    if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      createObject(
        className,
        relation,
        Some(expectedOutputAttributes),
        catalogTable)._1.asInstanceOf[LogicalRelation]
    } else if (SparkUtil.isSparkVersionEqualTo("2.2")) {
      createObject(
        className,
        relation,
        expectedOutputAttributes,
        catalogTable)._1.asInstanceOf[LogicalRelation]
    } else if (SparkUtil.isSparkVersionEqualTo("2.3")) {
      createObject(
        className,
        relation,
        expectedOutputAttributes,
        catalogTable,
        isStreaming.asInstanceOf[Object])._1.asInstanceOf[LogicalRelation]
    } else {
      throw new UnsupportedOperationException("Unsupported Spark version")
    }
  }


  def getOverWriteOption[T: TypeTag : reflect.ClassTag](name: String, obj: T): Boolean = {
    var overwriteboolean: Boolean = false
    val im = rm.reflect(obj)
    for (m <- typeOf[T].members.filter(!_.isMethod)) {
      if (m.toString.contains("overwrite")) {
        val typ = m.typeSignature
        if (typ.toString.contains("Boolean")) {
          // Spark2.2
          overwriteboolean = im.reflectField(m.asTerm).get.asInstanceOf[Boolean]
        } else {
          overwriteboolean = getOverWrite("enabled", im.reflectField(m.asTerm).get)
        }
      }
    }
    overwriteboolean
  }

  private def getOverWrite[T: TypeTag : reflect.ClassTag](name: String, obj: T): Boolean = {
    var overwriteboolean: Boolean = false
    val im = rm.reflect(obj)
    for (l <- im.symbol.typeSignature.members.filter(_.name.toString.contains("enabled"))) {
      overwriteboolean = im.reflectField(l.asTerm).get.asInstanceOf[Boolean]
    }
    overwriteboolean
  }

  def getFieldOfCatalogTable[T: TypeTag : reflect.ClassTag](name: String, obj: T): Any = {
    val im = rm.reflect(obj)
    val sym = im.symbol.typeSignature.member(TermName(name))
    val tableMeta = im.reflectMethod(sym.asMethod).apply()
    tableMeta
  }

  def getAstBuilder(conf: Object,
      sqlParser: Object,
      sparkSession: SparkSession): AstBuilder = {
    val className = sparkSession.sparkContext.conf.get(
      CarbonCommonConstants.CARBON_SQLASTBUILDER_CLASSNAME,
      CarbonCommonConstants.CARBON_SQLASTBUILDER_CLASSNAME_DEFAULT)
    createObject(className,
      conf,
      sqlParser, sparkSession)._1.asInstanceOf[AstBuilder]
  }

  def getSessionState(sparkContext: SparkContext,
      carbonSession: Object,
      useHiveMetaStore: Boolean): Any = {
    if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      val className = sparkContext.conf.get(
        CarbonCommonConstants.CARBON_SESSIONSTATE_CLASSNAME,
        "org.apache.spark.sql.hive.CarbonSessionState")
      createObject(className, carbonSession)._1
    } else if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      if (useHiveMetaStore) {
        val className = sparkContext.conf.get(
          CarbonCommonConstants.CARBON_SESSIONSTATE_CLASSNAME,
          "org.apache.spark.sql.hive.CarbonSessionStateBuilder")
        val tuple = createObject(className, carbonSession, None)
        val method = tuple._2.getMethod("build")
        method.invoke(tuple._1)
      } else {
        val className = sparkContext.conf.get(
          CarbonCommonConstants.CARBON_SESSIONSTATE_CLASSNAME,
          "org.apache.spark.sql.hive.CarbonInMemorySessionStateBuilder")
        val tuple = createObject(className, carbonSession, None)
        val method = tuple._2.getMethod("build")
        method.invoke(tuple._1)
      }
    } else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  def hasPredicateSubquery(filterExp: Expression) : Boolean = {
    if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      val tuple = Class.forName("org.apache.spark.sql.catalyst.expressions.PredicateSubquery")
      val method = tuple.getMethod("hasPredicateSubquery", classOf[Expression])
      val hasSubquery : Boolean = method.invoke(tuple, filterExp).asInstanceOf[Boolean]
      hasSubquery
    } else if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      val tuple = Class.forName("org.apache.spark.sql.catalyst.expressions.SubqueryExpression")
      val method = tuple.getMethod("hasInOrExistsSubquery", classOf[Expression])
      val hasSubquery : Boolean = method.invoke(tuple, filterExp).asInstanceOf[Boolean]
      hasSubquery
    } else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  def getDescribeTableFormattedField[T: TypeTag : reflect.ClassTag](obj: T): Boolean = {
    val im = rm.reflect(obj)
    val isFormatted = im.symbol.typeSignature.members
      .find(_.name.toString.equalsIgnoreCase("isFormatted"))
      .map(l => im.reflectField(l.asTerm).get).getOrElse("false").asInstanceOf[Boolean]
    isFormatted
  }

  def getRowDataSourceScanExecObj(relation: LogicalRelation,
      output: Seq[Attribute],
      pushedFilters: Seq[Filter],
      handledFilters: Seq[Filter],
      rdd: RDD[InternalRow],
      partition: Partitioning,
      metadata: Map[String, String]): RowDataSourceScanExec = {
    val className = "org.apache.spark.sql.execution.RowDataSourceScanExec"
    if (SparkUtil.isSparkVersionEqualTo("2.1") || SparkUtil.isSparkVersionEqualTo("2.2")) {
      createObject(className, output, rdd, relation.relation,
        partition, metadata,
        relation.catalogTable.map(_.identifier))._1.asInstanceOf[RowDataSourceScanExec]
    } else if (SparkUtil.isSparkVersionXandAbove("2.3")) {
      createObject(className, output, output.map(output.indexOf),
        pushedFilters.toSet, handledFilters.toSet, rdd,
        relation.relation,
        relation.catalogTable.map(_.identifier))._1.asInstanceOf[RowDataSourceScanExec]
    } else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  def invokewriteAndReadMethod(dataSourceObj: DataSource,
      dataFrame: DataFrame,
      data: LogicalPlan,
      session: SparkSession,
      mode: SaveMode,
      query: LogicalPlan,
      physicalPlan: SparkPlan): BaseRelation = {
    if (SparkUtil.isSparkVersionEqualTo("2.2")) {
      val method: Method = dataSourceObj.getClass
        .getMethod("writeAndRead", classOf[SaveMode], classOf[DataFrame])
      method.invoke(dataSourceObj, mode, dataFrame)
        .asInstanceOf[BaseRelation]
    } else if (SparkUtil.isSparkVersionEqualTo("2.3")) {
      val method: Method = dataSourceObj.getClass
        .getMethod("writeAndRead",
          classOf[SaveMode],
          classOf[LogicalPlan],
          classOf[Seq[String]],
          classOf[SparkPlan])
      // since spark 2.3.2 version (SPARK-PR#22346),
      // change 'query.output' to 'query.output.map(_.name)'
      method.invoke(dataSourceObj, mode, query, query.output.map(_.name), physicalPlan)
        .asInstanceOf[BaseRelation]
    } else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  /**
   * method to invoke alter table add columns for hive table from carbon session
   * @param table
   * @param colsToAdd
   * @return
   */
  def invokeAlterTableAddColumn(table: TableIdentifier,
      colsToAdd: Seq[StructField]): Object = {
    val caseClassName = "org.apache.spark.sql.execution.command.AlterTableAddColumnsCommand"
    CarbonReflectionUtils.createObject(caseClassName, table, colsToAdd)
      ._1.asInstanceOf[RunnableCommand]
  }

  def createObject(className: String, conArgs: Object*): (Any, Class[_]) = {
    val clazz = Utils.classForName(className)
    val ctor = clazz.getConstructors.head
    ctor.setAccessible(true)
    (ctor.newInstance(conArgs: _*), clazz)
  }

  def createObjectOfPrivateConstructor(className: String, conArgs: Object*): (Any, Class[_]) = {
    val clazz = Utils.classForName(className)
    val ctor = clazz.getDeclaredConstructors.head
    ctor.setAccessible(true)
    (ctor.newInstance(conArgs: _*), clazz)
  }
}

1	/*
2	* Licensed to the Apache Software Foundation (ASF) under one or more
3	* contributor license agreements. See the NOTICE file distributed with
4	* this work for additional information regarding copyright ownership.
5	* The ASF licenses this file to You under the Apache License, Version 2.0
6	* (the "License"); you may not use this file except in compliance with
7	* the License. You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*/
17
18	package org.apache.spark.util
19
20	import java.lang.reflect.Method
21
22	import scala.reflect.runtime._
23	import scala.reflect.runtime.universe._
24
25	import org.apache.spark.{SPARK_VERSION, SparkContext}
26	import org.apache.spark.rdd.RDD
27	import org.apache.spark.sql.{DataFrame, SaveMode, SparkSession}
28	import org.apache.spark.sql.catalyst.{InternalRow, TableIdentifier}
29	import org.apache.spark.sql.catalyst.analysis.UnresolvedRelation
30	import org.apache.spark.sql.catalyst.catalog.CatalogTable
31	import org.apache.spark.sql.catalyst.expressions.{Attribute, Expression}
32	import org.apache.spark.sql.catalyst.parser.AstBuilder
33	import org.apache.spark.sql.catalyst.plans.logical.{InsertIntoTable, LogicalPlan, SubqueryAlias}
34	import org.apache.spark.sql.catalyst.plans.physical.Partitioning
35	import org.apache.spark.sql.execution.{RowDataSourceScanExec, SparkPlan}
36	import org.apache.spark.sql.execution.command.RunnableCommand
37	import org.apache.spark.sql.execution.datasources.{DataSource, LogicalRelation}
38	import org.apache.spark.sql.sources.{BaseRelation, Filter}
39	import org.apache.spark.sql.types.StructField
40
41	import org.apache.carbondata.core.constants.CarbonCommonConstants
42
43	/**
44	* Reflection APIs
45	*/
46
47	object CarbonReflectionUtils {
48	private val rm = universe.runtimeMirror(getClass.getClassLoader)	1✔
49
50	/**
51	* Returns the field val from a object through reflection.
52	* @param name - name of the field being retrieved.
53	* @param obj - Object from which the field has to be retrieved.
54	* @tparam T
55	* @return
56	*/
57	def getField[T: TypeTag : reflect.ClassTag](name: String, obj: T): Any = {
58	val im = rm.reflect(obj)	×
59	im.symbol.typeSignature.members.find(_.name.toString.equals(name))	×
60	.map(l => im.reflectField(l.asTerm).get).getOrElse(null)	×
61	}
62
63	def getUnresolvedRelation(
64	tableIdentifier: TableIdentifier,
65	tableAlias: Option[String] = None): UnresolvedRelation = {	1✔
66	val className = "org.apache.spark.sql.catalyst.analysis.UnresolvedRelation"	1✔
67	if (SparkUtil.isSparkVersionEqualTo("2.1")) {	1✔
68	createObject(	×
69	className,	×
70	tableIdentifier,	×
71	tableAlias)._1.asInstanceOf[UnresolvedRelation]	×
72	} else if (SparkUtil.isSparkVersionXandAbove("2.2")) {	1✔
73	createObject(	1✔
74	className,	1✔
75	tableIdentifier)._1.asInstanceOf[UnresolvedRelation]	1✔
76	} else {
77	throw new UnsupportedOperationException(s"Unsupported Spark version $SPARK_VERSION")	×
78	}
79	}
80
81	def getSubqueryAlias(sparkSession: SparkSession, alias: Option[String],
82	relation: LogicalPlan,
83	view: Option[TableIdentifier]): SubqueryAlias = {	1✔
84	val className = "org.apache.spark.sql.catalyst.plans.logical.SubqueryAlias"	1✔
85	if (SparkUtil.isSparkVersionEqualTo("2.1")) {	1✔
86	createObject(	×
87	className,	×
88	alias.getOrElse(""),	×
89	relation,	×
90	Option(view))._1.asInstanceOf[SubqueryAlias]	×
91	} else if (SparkUtil.isSparkVersionXandAbove("2.2")) {	1✔
92	createObject(	1✔
93	className,	1✔
94	alias.getOrElse(""),	1✔
95	relation)._1.asInstanceOf[SubqueryAlias]	1✔
96	} else {
97	throw new UnsupportedOperationException("Unsupported Spark version")	×
98	}
99	}
100
101	def getInsertIntoCommand(table: LogicalPlan,
102	partition: Map[String, Option[String]],
103	query: LogicalPlan,
104	overwrite: Boolean,
105	ifPartitionNotExists: Boolean): InsertIntoTable = {	1✔
106	val className = "org.apache.spark.sql.catalyst.plans.logical.InsertIntoTable"	1✔
107	if (SparkUtil.isSparkVersionEqualTo("2.1")) {	1✔
108	val overwriteOptions = createObject(	×
109	"org.apache.spark.sql.catalyst.plans.logical.OverwriteOptions",	×
110	overwrite.asInstanceOf[Object], Map.empty.asInstanceOf[Object])._1.asInstanceOf[Object]	×
111	createObject(	×
112	className,	×
113	table,	×
114	partition,	×
115	query,	×
116	overwriteOptions,	×
117	ifPartitionNotExists.asInstanceOf[Object])._1.asInstanceOf[InsertIntoTable]	×
118	} else if (SparkUtil.isSparkVersionXandAbove("2.2") ) {	1✔
119	createObject(	1✔
120	className,	1✔
121	table,	1✔
122	partition,	1✔
123	query,	1✔
124	overwrite.asInstanceOf[Object],	1✔
125	ifPartitionNotExists.asInstanceOf[Object])._1.asInstanceOf[InsertIntoTable]	1✔
126	} else {
127	throw new UnsupportedOperationException("Unsupported Spark version")	×
128	}
129	}
130
131	def getLogicalRelation(relation: BaseRelation,
132	expectedOutputAttributes: Seq[Attribute],
133	catalogTable: Option[CatalogTable],
134	isStreaming: Boolean): LogicalRelation = {	1✔
135	val className = "org.apache.spark.sql.execution.datasources.LogicalRelation"	1✔
136	if (SparkUtil.isSparkVersionEqualTo("2.1")) {	1✔
137	createObject(	×
138	className,	×
139	relation,	×
140	Some(expectedOutputAttributes),	×
141	catalogTable)._1.asInstanceOf[LogicalRelation]	×
142	} else if (SparkUtil.isSparkVersionEqualTo("2.2")) {	1✔
143	createObject(	×
144	className,	×
145	relation,	×
146	expectedOutputAttributes,	×
147	catalogTable)._1.asInstanceOf[LogicalRelation]	×
148	} else if (SparkUtil.isSparkVersionEqualTo("2.3")) {	1✔
149	createObject(	1✔
150	className,	1✔
151	relation,	1✔
152	expectedOutputAttributes,	1✔
153	catalogTable,	1✔
154	isStreaming.asInstanceOf[Object])._1.asInstanceOf[LogicalRelation]	1✔
155	} else {
156	throw new UnsupportedOperationException("Unsupported Spark version")	×
157	}
158	}
159
160
161	def getOverWriteOption[T: TypeTag : reflect.ClassTag](name: String, obj: T): Boolean = {
162	var overwriteboolean: Boolean = false	1✔
163	val im = rm.reflect(obj)	1✔
164	for (m <- typeOf[T].members.filter(!_.isMethod)) {	1✔
165	if (m.toString.contains("overwrite")) {	1✔
166	val typ = m.typeSignature	1✔
167	if (typ.toString.contains("Boolean")) {	1✔
168	// Spark2.2
169	overwriteboolean = im.reflectField(m.asTerm).get.asInstanceOf[Boolean]	1✔
170	} else {
171	overwriteboolean = getOverWrite("enabled", im.reflectField(m.asTerm).get)	×
172	}
173	}
174	}
175	overwriteboolean	1✔
176	}
177
178	private def getOverWrite[T: TypeTag : reflect.ClassTag](name: String, obj: T): Boolean = {
179	var overwriteboolean: Boolean = false	×
180	val im = rm.reflect(obj)	×
181	for (l <- im.symbol.typeSignature.members.filter(_.name.toString.contains("enabled"))) {	×
182	overwriteboolean = im.reflectField(l.asTerm).get.asInstanceOf[Boolean]	×
183	}
184	overwriteboolean	×
185	}
186
187	def getFieldOfCatalogTable[T: TypeTag : reflect.ClassTag](name: String, obj: T): Any = {
188	val im = rm.reflect(obj)	1✔
189	val sym = im.symbol.typeSignature.member(TermName(name))	1✔
190	val tableMeta = im.reflectMethod(sym.asMethod).apply()	1✔
191	tableMeta	1✔
192	}
193
194	def getAstBuilder(conf: Object,
195	sqlParser: Object,
196	sparkSession: SparkSession): AstBuilder = {
197	val className = sparkSession.sparkContext.conf.get(	1✔
198	CarbonCommonConstants.CARBON_SQLASTBUILDER_CLASSNAME,	1✔
199	CarbonCommonConstants.CARBON_SQLASTBUILDER_CLASSNAME_DEFAULT)	1✔
200	createObject(className,	1✔
201	conf,	1✔
202	sqlParser, sparkSession)._1.asInstanceOf[AstBuilder]	1✔
203	}
204
205	def getSessionState(sparkContext: SparkContext,
206	carbonSession: Object,
207	useHiveMetaStore: Boolean): Any = {
208	if (SparkUtil.isSparkVersionEqualTo("2.1")) {	1✔
209	val className = sparkContext.conf.get(	×
210	CarbonCommonConstants.CARBON_SESSIONSTATE_CLASSNAME,	×
211	"org.apache.spark.sql.hive.CarbonSessionState")	×
212	createObject(className, carbonSession)._1	×
213	} else if (SparkUtil.isSparkVersionXandAbove("2.2")) {	1✔
214	if (useHiveMetaStore) {	1✔
215	val className = sparkContext.conf.get(	1✔
216	CarbonCommonConstants.CARBON_SESSIONSTATE_CLASSNAME,	1✔
217	"org.apache.spark.sql.hive.CarbonSessionStateBuilder")	1✔
218	val tuple = createObject(className, carbonSession, None)	1✔
219	val method = tuple._2.getMethod("build")	1✔
220	method.invoke(tuple._1)	1✔
221	} else {
222	val className = sparkContext.conf.get(	×
223	CarbonCommonConstants.CARBON_SESSIONSTATE_CLASSNAME,	×
224	"org.apache.spark.sql.hive.CarbonInMemorySessionStateBuilder")	×
225	val tuple = createObject(className, carbonSession, None)	×
226	val method = tuple._2.getMethod("build")	×
227	method.invoke(tuple._1)	×
228	}
229	} else {
230	throw new UnsupportedOperationException("Spark version not supported")	×
231	}
232	}
233
234	def hasPredicateSubquery(filterExp: Expression) : Boolean = {
235	if (SparkUtil.isSparkVersionEqualTo("2.1")) {	1✔
236	val tuple = Class.forName("org.apache.spark.sql.catalyst.expressions.PredicateSubquery")	×
237	val method = tuple.getMethod("hasPredicateSubquery", classOf[Expression])	×
238	val hasSubquery : Boolean = method.invoke(tuple, filterExp).asInstanceOf[Boolean]	×
239	hasSubquery	×
240	} else if (SparkUtil.isSparkVersionXandAbove("2.2")) {	1✔
241	val tuple = Class.forName("org.apache.spark.sql.catalyst.expressions.SubqueryExpression")	1✔
242	val method = tuple.getMethod("hasInOrExistsSubquery", classOf[Expression])	1✔
243	val hasSubquery : Boolean = method.invoke(tuple, filterExp).asInstanceOf[Boolean]	1✔
244	hasSubquery	1✔
245	} else {
246	throw new UnsupportedOperationException("Spark version not supported")	×
247	}
248	}
249
250	def getDescribeTableFormattedField[T: TypeTag : reflect.ClassTag](obj: T): Boolean = {
251	val im = rm.reflect(obj)	×
252	val isFormatted = im.symbol.typeSignature.members	×
253	.find(_.name.toString.equalsIgnoreCase("isFormatted"))	×
254	.map(l => im.reflectField(l.asTerm).get).getOrElse("false").asInstanceOf[Boolean]	×
255	isFormatted	×
256	}
257
258	def getRowDataSourceScanExecObj(relation: LogicalRelation,
259	output: Seq[Attribute],
260	pushedFilters: Seq[Filter],
261	handledFilters: Seq[Filter],
262	rdd: RDD[InternalRow],
263	partition: Partitioning,
264	metadata: Map[String, String]): RowDataSourceScanExec = {	1✔
265	val className = "org.apache.spark.sql.execution.RowDataSourceScanExec"	1✔
266	if (SparkUtil.isSparkVersionEqualTo("2.1") \|\| SparkUtil.isSparkVersionEqualTo("2.2")) {	1✔
267	createObject(className, output, rdd, relation.relation,	×
268	partition, metadata,	×
269	relation.catalogTable.map(_.identifier))._1.asInstanceOf[RowDataSourceScanExec]	×
270	} else if (SparkUtil.isSparkVersionXandAbove("2.3")) {	1✔
271	createObject(className, output, output.map(output.indexOf),	1✔
272	pushedFilters.toSet, handledFilters.toSet, rdd,	1✔
273	relation.relation,	1✔
274	relation.catalogTable.map(_.identifier))._1.asInstanceOf[RowDataSourceScanExec]	1✔
275	} else {
276	throw new UnsupportedOperationException("Spark version not supported")	×
277	}
278	}
279
280	def invokewriteAndReadMethod(dataSourceObj: DataSource,
281	dataFrame: DataFrame,
282	data: LogicalPlan,
283	session: SparkSession,
284	mode: SaveMode,
285	query: LogicalPlan,
286	physicalPlan: SparkPlan): BaseRelation = {
287	if (SparkUtil.isSparkVersionEqualTo("2.2")) {	1✔
288	val method: Method = dataSourceObj.getClass	×
289	.getMethod("writeAndRead", classOf[SaveMode], classOf[DataFrame])	×
290	method.invoke(dataSourceObj, mode, dataFrame)	×
291	.asInstanceOf[BaseRelation]
292	} else if (SparkUtil.isSparkVersionEqualTo("2.3")) {	1✔
293	val method: Method = dataSourceObj.getClass	1✔
294	.getMethod("writeAndRead",	1✔
295	classOf[SaveMode],	1✔
296	classOf[LogicalPlan],	1✔
297	classOf[Seq[String]],	1✔
298	classOf[SparkPlan])	1✔
299	// since spark 2.3.2 version (SPARK-PR#22346),
300	// change 'query.output' to 'query.output.map(_.name)'
301	method.invoke(dataSourceObj, mode, query, query.output.map(_.name), physicalPlan)	1✔
302	.asInstanceOf[BaseRelation]
303	} else {
304	throw new UnsupportedOperationException("Spark version not supported")	×
305	}
306	}
307
308	/**
309	* method to invoke alter table add columns for hive table from carbon session
310	* @param table
311	* @param colsToAdd
312	* @return
313	*/
314	def invokeAlterTableAddColumn(table: TableIdentifier,
315	colsToAdd: Seq[StructField]): Object = {
316	val caseClassName = "org.apache.spark.sql.execution.command.AlterTableAddColumnsCommand"	×
317	CarbonReflectionUtils.createObject(caseClassName, table, colsToAdd)	×
318	._1.asInstanceOf[RunnableCommand]	×
319	}
320
321	def createObject(className: String, conArgs: Object*): (Any, Class[_]) = {
322	val clazz = Utils.classForName(className)	1✔
323	val ctor = clazz.getConstructors.head	1✔
324	ctor.setAccessible(true)	1✔
325	(ctor.newInstance(conArgs: _*), clazz)	1✔
326	}
327
328	def createObjectOfPrivateConstructor(className: String, conArgs: Object*): (Any, Class[_]) = {
329	val clazz = Utils.classForName(className)	×
330	val ctor = clazz.getDeclaredConstructors.head	×
331	ctor.setAccessible(true)	×
332	(ctor.newInstance(conArgs: _*), clazz)	×
333	}
334	}	1✔

apache / carbondata / 10148

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous