3477

Build # 3477

Build Type

push

jenkins

Committed by GitHub

Commit Message

<a href="https://github.com/apache/carbondata/commit/<a class=hub.com/apache/carbondata/commit/8e007145a1fd9fa7e2886ed2eeeadb112050666c">8e007145a<a href="https://github.com/apache/carbondata/commit/8e007145a1fd9fa7e2886ed2eeeadb112050666c">">Merge </a><a class="double-link" href="https://github.com/apache/carbondata/commit/<a class="double-link" href="https://github.com/apache/carbondata/commit/0f35c568eebd70218fa727d79dc60f5849762c0d">0f35c568e</a>">0f35c568e</a><a href="https://github.com/apache/carbondata/commit/8e007145a1fd9fa7e2886ed2eeeadb112050666c"> into 24fe230a9">24fe230a9</a>

Run Details

70 of 70 new or added lines in 4 files covered. (100.0%)

63973 of 81532 relevant lines covered (78.46%)

1.04 hits per line

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

4.9

/integration/spark-common/src/main/scala/org/apache/spark/sql/util/SparkSQLUtil.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.sql.util

import java.lang.reflect.Method

import org.apache.hadoop.conf.Configuration
import org.apache.spark.SparkContext
import org.apache.spark.broadcast.Broadcast
import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}
import org.apache.spark.sql.catalyst.analysis.EmptyRule
import org.apache.spark.sql.catalyst.expressions.{Attribute, AttributeMap, AttributeSeq, Cast, Expression, NamedExpression}
import org.apache.spark.sql.catalyst.plans.logical
import org.apache.spark.sql.catalyst.plans.logical.{ColumnStat, LogicalPlan, Statistics}
import org.apache.spark.sql.catalyst.rules.Rule
import org.apache.spark.sql.internal.{SessionState, SQLConf}
import org.apache.spark.sql.types.DataType
import org.apache.spark.util.{CarbonReflectionUtils, SerializableConfiguration, SparkUtil, Utils}

object SparkSQLUtil {
  def sessionState(sparkSession: SparkSession): SessionState = sparkSession.sessionState

  def execute(logicalPlan: LogicalPlan, sparkSession: SparkSession): DataFrame = {
    Dataset.ofRows(sparkSession, logicalPlan)
  }

  def getSparkSession: SparkSession = {
    SparkSession.getDefaultSession.get
  }

  def invokeStatsMethod(logicalPlanObj: LogicalPlan, conf: SQLConf): Statistics = {
    if (SparkUtil.isSparkVersionEqualTo("2.2")) {
      val method: Method = logicalPlanObj.getClass.getMethod("stats", classOf[SQLConf])
      method.invoke(logicalPlanObj, conf).asInstanceOf[Statistics]
    } else if (SparkUtil.isSparkVersionXandAbove("2.3")) {
      val method: Method = logicalPlanObj.getClass.getMethod("stats")
      method.invoke(logicalPlanObj).asInstanceOf[Statistics]
    } else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  def invokeQueryPlannormalizeExprId(r: NamedExpression, input: AttributeSeq)
      : NamedExpression = {
    if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      val clazz = Utils.classForName("org.apache.spark.sql.catalyst.plans.QueryPlan")
      clazz.getDeclaredMethod("normalizeExprId", classOf[Any], classOf[AttributeSeq]).
        invoke(null, r, input).asInstanceOf[NamedExpression]
    } else {
      r
    }
  }

  def getStatisticsObj(outputList: Seq[NamedExpression],
                       plan: LogicalPlan, stats: Statistics,
                       aliasMap: Option[AttributeMap[Attribute]] = None)
  : Statistics = {
    val className = "org.apache.spark.sql.catalyst.plans.logical.Statistics"
    if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      val output = outputList.map(_.toAttribute)
      val mapSeq = plan.collect { case n: logical.LeafNode => n }.map {
        table => AttributeMap(table.output.zip(output))
      }
      val rewrites = mapSeq.head
      val attributes : AttributeMap[ColumnStat] = CarbonReflectionUtils.
        getField("attributeStats", stats).asInstanceOf[AttributeMap[ColumnStat]]
      var attributeStats = AttributeMap(attributes.iterator
        .map { pair => (rewrites(pair._1), pair._2) }.toSeq)
      if (aliasMap.isDefined) {
        attributeStats = AttributeMap(
          attributeStats.map(pair => (aliasMap.get(pair._1), pair._2)).toSeq)
      }
      val hints = CarbonReflectionUtils.getField("hints", stats).asInstanceOf[Object]
      CarbonReflectionUtils.createObject(className, stats.sizeInBytes,
        stats.rowCount, attributeStats, hints).asInstanceOf[Statistics]
    } else {
      val output = outputList.map(_.name)
      val mapSeq = plan.collect { case n: logical.LeafNode => n }.map {
        table => table.output.map(_.name).zip(output).toMap
      }
      val rewrites = mapSeq.head
      val colStats = CarbonReflectionUtils.getField("colStats", stats)
        .asInstanceOf[Map[String, ColumnStat]]
      var attributeStats = colStats.iterator
        .map { pair => (rewrites(pair._1), pair._2) }.toMap
      if (aliasMap.isDefined) {
        val aliasMapName = aliasMap.get.map(x => (x._1.name, x._2.name))
        attributeStats =
          attributeStats.map(pair => (aliasMapName.getOrElse(pair._1, pair._1)
            , pair._2))
      }
      CarbonReflectionUtils.createObject(className, stats.sizeInBytes,
        stats.rowCount, attributeStats).asInstanceOf[Statistics]
    }
  }

  def getEliminateViewObj(): Rule[LogicalPlan] = {
    if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      val className = "org.apache.spark.sql.catalyst.analysis.EliminateView"
      CarbonReflectionUtils.createSingleObject(className).asInstanceOf[Rule[LogicalPlan]]
    } else {
      EmptyRule
    }
  }

  def getPullupCorrelatedPredicatesObj(): Rule[LogicalPlan] = {
    if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.PullupCorrelatedPredicates"
      CarbonReflectionUtils.createSingleObject(className).asInstanceOf[Rule[LogicalPlan]]
    } else {
      EmptyRule
    }
  }

  def getRemoveRedundantAliasesObj(): Rule[LogicalPlan] = {
    if (SparkUtil.isSparkVersionXandAbove("2.2")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.RemoveRedundantAliases"
      CarbonReflectionUtils.createSingleObject(className).asInstanceOf[Rule[LogicalPlan]]
    } else {
      EmptyRule
    }
  }

  def getReorderJoinObj(conf: SQLConf): Rule[LogicalPlan] = {
    if (SparkUtil.isSparkVersionEqualTo("2.2")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.ReorderJoin";
      CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionXandAbove("2.3")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.ReorderJoin$";
      CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1
        .asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.ReorderJoin$";
      CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1
        .asInstanceOf[Rule[LogicalPlan]]
    }
    else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  def getEliminateOuterJoinObj(conf: SQLConf): Rule[LogicalPlan] = {
    if (SparkUtil.isSparkVersionEqualTo("2.2")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.EliminateOuterJoin";
      CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionXandAbove("2.3")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.EliminateOuterJoin$";
      CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1
        .asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.EliminateOuterJoin$";
      CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1
        .asInstanceOf[Rule[LogicalPlan]]
    }
    else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  def getNullPropagationObj(conf: SQLConf): Rule[LogicalPlan] = {
    if (SparkUtil.isSparkVersionEqualTo("2.2")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.NullPropagation";
      CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionXandAbove("2.3")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.NullPropagation$";
      CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1
        .asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.NullPropagation$";
      CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1
        .asInstanceOf[Rule[LogicalPlan]]
    } else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  def getCheckCartesianProductsObj(conf: SQLConf): Rule[LogicalPlan] = {
    if (SparkUtil.isSparkVersionEqualTo("2.2")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.CheckCartesianProducts";
      CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionXandAbove("2.3")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.CheckCartesianProducts$";
      CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1
        .asInstanceOf[Rule[LogicalPlan]]
    } else if (SparkUtil.isSparkVersionEqualTo("2.1")) {
      val className = "org.apache.spark.sql.catalyst.optimizer.CheckCartesianProducts";
      CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]
    }
    else {
      throw new UnsupportedOperationException("Spark version not supported")
    }
  }

  /**
   * Method to broadcast a variable using spark SerializableConfiguration class
   *
   * @param sparkContext
   * @param hadoopConf
   * @return
   */
  def broadCastHadoopConf(sparkContext: SparkContext,
      hadoopConf: Configuration): Broadcast[SerializableConfiguration] = {
    sparkContext.broadcast(getSerializableConfigurableInstance(hadoopConf))
  }

  def getSerializableConfigurableInstance(hadoopConf: Configuration): SerializableConfiguration = {
    new SerializableConfiguration(hadoopConf)
  }
}

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.sql.util
19
20	import java.lang.reflect.Method
21
22	import org.apache.hadoop.conf.Configuration
23	import org.apache.spark.SparkContext
24	import org.apache.spark.broadcast.Broadcast
25	import org.apache.spark.sql.{DataFrame, Dataset, SparkSession}
26	import org.apache.spark.sql.catalyst.analysis.EmptyRule
27	import org.apache.spark.sql.catalyst.expressions.{Attribute, AttributeMap, AttributeSeq, Cast, Expression, NamedExpression}
28	import org.apache.spark.sql.catalyst.plans.logical
29	import org.apache.spark.sql.catalyst.plans.logical.{ColumnStat, LogicalPlan, Statistics}
30	import org.apache.spark.sql.catalyst.rules.Rule
31	import org.apache.spark.sql.internal.{SessionState, SQLConf}
32	import org.apache.spark.sql.types.DataType
33	import org.apache.spark.util.{CarbonReflectionUtils, SerializableConfiguration, SparkUtil, Utils}
34
35	object SparkSQLUtil {
36	def sessionState(sparkSession: SparkSession): SessionState = sparkSession.sessionState	1✔
37
38	def execute(logicalPlan: LogicalPlan, sparkSession: SparkSession): DataFrame = {
39	Dataset.ofRows(sparkSession, logicalPlan)	×
40	}
41
42	def getSparkSession: SparkSession = {
43	SparkSession.getDefaultSession.get	1✔
44	}
45
46	def invokeStatsMethod(logicalPlanObj: LogicalPlan, conf: SQLConf): Statistics = {
47	if (SparkUtil.isSparkVersionEqualTo("2.2")) {	×
48	val method: Method = logicalPlanObj.getClass.getMethod("stats", classOf[SQLConf])	×
49	method.invoke(logicalPlanObj, conf).asInstanceOf[Statistics]	×
50	} else if (SparkUtil.isSparkVersionXandAbove("2.3")) {	×
51	val method: Method = logicalPlanObj.getClass.getMethod("stats")	×
52	method.invoke(logicalPlanObj).asInstanceOf[Statistics]	×
53	} else {
54	throw new UnsupportedOperationException("Spark version not supported")	×
55	}
56	}
57
58	def invokeQueryPlannormalizeExprId(r: NamedExpression, input: AttributeSeq)
59	: NamedExpression = {
60	if (SparkUtil.isSparkVersionXandAbove("2.2")) {	×
61	val clazz = Utils.classForName("org.apache.spark.sql.catalyst.plans.QueryPlan")	×
62	clazz.getDeclaredMethod("normalizeExprId", classOf[Any], classOf[AttributeSeq]).	×
63	invoke(null, r, input).asInstanceOf[NamedExpression]	×
64	} else {
65	r	×
66	}
67	}
68
69	def getStatisticsObj(outputList: Seq[NamedExpression],
70	plan: LogicalPlan, stats: Statistics,
71	aliasMap: Option[AttributeMap[Attribute]] = None)	×
72	: Statistics = {	×
73	val className = "org.apache.spark.sql.catalyst.plans.logical.Statistics"	×
74	if (SparkUtil.isSparkVersionXandAbove("2.2")) {	×
75	val output = outputList.map(_.toAttribute)	×
76	val mapSeq = plan.collect { case n: logical.LeafNode => n }.map {	×
77	table => AttributeMap(table.output.zip(output))	×
78	}
79	val rewrites = mapSeq.head	×
80	val attributes : AttributeMap[ColumnStat] = CarbonReflectionUtils.	×
81	getField("attributeStats", stats).asInstanceOf[AttributeMap[ColumnStat]]	×
82	var attributeStats = AttributeMap(attributes.iterator	×
83	.map { pair => (rewrites(pair._1), pair._2) }.toSeq)	×
84	if (aliasMap.isDefined) {	×
85	attributeStats = AttributeMap(	×
86	attributeStats.map(pair => (aliasMap.get(pair._1), pair._2)).toSeq)	×
87	}
88	val hints = CarbonReflectionUtils.getField("hints", stats).asInstanceOf[Object]	×
89	CarbonReflectionUtils.createObject(className, stats.sizeInBytes,	×
90	stats.rowCount, attributeStats, hints).asInstanceOf[Statistics]	×
91	} else {
92	val output = outputList.map(_.name)	×
93	val mapSeq = plan.collect { case n: logical.LeafNode => n }.map {	×
94	table => table.output.map(_.name).zip(output).toMap	×
95	}
96	val rewrites = mapSeq.head	×
97	val colStats = CarbonReflectionUtils.getField("colStats", stats)	×
98	.asInstanceOf[Map[String, ColumnStat]]
99	var attributeStats = colStats.iterator	×
100	.map { pair => (rewrites(pair._1), pair._2) }.toMap	×
101	if (aliasMap.isDefined) {	×
102	val aliasMapName = aliasMap.get.map(x => (x._1.name, x._2.name))	×
103	attributeStats =	×
104	attributeStats.map(pair => (aliasMapName.getOrElse(pair._1, pair._1)	×
105	, pair._2))	×
106	}
107	CarbonReflectionUtils.createObject(className, stats.sizeInBytes,	×
108	stats.rowCount, attributeStats).asInstanceOf[Statistics]	×
109	}
110	}
111
112	def getEliminateViewObj(): Rule[LogicalPlan] = {
113	if (SparkUtil.isSparkVersionXandAbove("2.2")) {	×
114	val className = "org.apache.spark.sql.catalyst.analysis.EliminateView"	×
115	CarbonReflectionUtils.createSingleObject(className).asInstanceOf[Rule[LogicalPlan]]	×
116	} else {
117	EmptyRule	×
118	}
119	}
120
121	def getPullupCorrelatedPredicatesObj(): Rule[LogicalPlan] = {
122	if (SparkUtil.isSparkVersionXandAbove("2.2")) {	×
123	val className = "org.apache.spark.sql.catalyst.optimizer.PullupCorrelatedPredicates"	×
124	CarbonReflectionUtils.createSingleObject(className).asInstanceOf[Rule[LogicalPlan]]	×
125	} else {
126	EmptyRule	×
127	}
128	}
129
130	def getRemoveRedundantAliasesObj(): Rule[LogicalPlan] = {
131	if (SparkUtil.isSparkVersionXandAbove("2.2")) {	×
132	val className = "org.apache.spark.sql.catalyst.optimizer.RemoveRedundantAliases"	×
133	CarbonReflectionUtils.createSingleObject(className).asInstanceOf[Rule[LogicalPlan]]	×
134	} else {
135	EmptyRule	×
136	}
137	}
138
139	def getReorderJoinObj(conf: SQLConf): Rule[LogicalPlan] = {
140	if (SparkUtil.isSparkVersionEqualTo("2.2")) {	×
141	val className = "org.apache.spark.sql.catalyst.optimizer.ReorderJoin";	×
142	CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]	×
143	} else if (SparkUtil.isSparkVersionXandAbove("2.3")) {	×
144	val className = "org.apache.spark.sql.catalyst.optimizer.ReorderJoin$";	×
145	CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1	×
146	.asInstanceOf[Rule[LogicalPlan]]
147	} else if (SparkUtil.isSparkVersionEqualTo("2.1")) {	×
148	val className = "org.apache.spark.sql.catalyst.optimizer.ReorderJoin$";	×
149	CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1	×
150	.asInstanceOf[Rule[LogicalPlan]]
151	}
152	else {
153	throw new UnsupportedOperationException("Spark version not supported")	×
154	}
155	}
156
157	def getEliminateOuterJoinObj(conf: SQLConf): Rule[LogicalPlan] = {
158	if (SparkUtil.isSparkVersionEqualTo("2.2")) {	×
159	val className = "org.apache.spark.sql.catalyst.optimizer.EliminateOuterJoin";	×
160	CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]	×
161	} else if (SparkUtil.isSparkVersionXandAbove("2.3")) {	×
162	val className = "org.apache.spark.sql.catalyst.optimizer.EliminateOuterJoin$";	×
163	CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1	×
164	.asInstanceOf[Rule[LogicalPlan]]
165	} else if (SparkUtil.isSparkVersionEqualTo("2.1")) {	×
166	val className = "org.apache.spark.sql.catalyst.optimizer.EliminateOuterJoin$";	×
167	CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1	×
168	.asInstanceOf[Rule[LogicalPlan]]
169	}
170	else {
171	throw new UnsupportedOperationException("Spark version not supported")	×
172	}
173	}
174
175	def getNullPropagationObj(conf: SQLConf): Rule[LogicalPlan] = {
176	if (SparkUtil.isSparkVersionEqualTo("2.2")) {	×
177	val className = "org.apache.spark.sql.catalyst.optimizer.NullPropagation";	×
178	CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]	×
179	} else if (SparkUtil.isSparkVersionXandAbove("2.3")) {	×
180	val className = "org.apache.spark.sql.catalyst.optimizer.NullPropagation$";	×
181	CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1	×
182	.asInstanceOf[Rule[LogicalPlan]]
183	} else if (SparkUtil.isSparkVersionEqualTo("2.1")) {	×
184	val className = "org.apache.spark.sql.catalyst.optimizer.NullPropagation$";	×
185	CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1	×
186	.asInstanceOf[Rule[LogicalPlan]]
187	} else {
188	throw new UnsupportedOperationException("Spark version not supported")	×
189	}
190	}
191
192	def getCheckCartesianProductsObj(conf: SQLConf): Rule[LogicalPlan] = {
193	if (SparkUtil.isSparkVersionEqualTo("2.2")) {	×
194	val className = "org.apache.spark.sql.catalyst.optimizer.CheckCartesianProducts";	×
195	CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]	×
196	} else if (SparkUtil.isSparkVersionXandAbove("2.3")) {	×
197	val className = "org.apache.spark.sql.catalyst.optimizer.CheckCartesianProducts$";	×
198	CarbonReflectionUtils.createObjectOfPrivateConstructor(className)._1	×
199	.asInstanceOf[Rule[LogicalPlan]]
200	} else if (SparkUtil.isSparkVersionEqualTo("2.1")) {	×
201	val className = "org.apache.spark.sql.catalyst.optimizer.CheckCartesianProducts";	×
202	CarbonReflectionUtils.createObject(className, conf)._1.asInstanceOf[Rule[LogicalPlan]]	×
203	}
204	else {
205	throw new UnsupportedOperationException("Spark version not supported")	×
206	}
207	}
208
209	/**
210	* Method to broadcast a variable using spark SerializableConfiguration class
211	*
212	* @param sparkContext
213	* @param hadoopConf
214	* @return
215	*/
216	def broadCastHadoopConf(sparkContext: SparkContext,
217	hadoopConf: Configuration): Broadcast[SerializableConfiguration] = {
218	sparkContext.broadcast(getSerializableConfigurableInstance(hadoopConf))	1✔
219	}
220
221	def getSerializableConfigurableInstance(hadoopConf: Configuration): SerializableConfiguration = {
222	new SerializableConfiguration(hadoopConf)	1✔
223	}
224	}	1✔

apache / carbondata / 3477

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