diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/catalog/SessionCatalog.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/catalog/SessionCatalog.scala
index 336d3d65d0dd083c34780407e53da83a05fdee25..c40d5f6031a21eae5193609e5f1053083e43f5d0 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/catalog/SessionCatalog.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/catalog/SessionCatalog.scala
@@ -74,7 +74,7 @@ class SessionCatalog(
functionRegistry,
conf,
new Configuration(),
- CatalystSqlParser,
+ new CatalystSqlParser(conf),
DummyFunctionResourceLoader)
}
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala
index 4d725904bc9b9bd1c081cba4734e3277c876a8e6..a616b0f773f382798c7c478434d99d42422432e6 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala
@@ -45,9 +45,11 @@ import org.apache.spark.util.random.RandomSampler
* The AstBuilder converts an ANTLR4 ParseTree into a catalyst Expression, LogicalPlan or
* TableIdentifier.
*/
-class AstBuilder extends SqlBaseBaseVisitor[AnyRef] with Logging {
+class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging {
import ParserUtils._
+ def this() = this(new SQLConf())
+
protected def typedVisit[T](ctx: ParseTree): T = {
ctx.accept(this).asInstanceOf[T]
}
@@ -1457,7 +1459,7 @@ class AstBuilder extends SqlBaseBaseVisitor[AnyRef] with Logging {
* Special characters can be escaped by using Hive/C-style escaping.
*/
private def createString(ctx: StringLiteralContext): String = {
- if (SQLConf.get.escapedStringLiterals) {
+ if (conf.escapedStringLiterals) {
ctx.STRING().asScala.map(stringWithoutUnescape).mkString
} else {
ctx.STRING().asScala.map(string).mkString
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/ParseDriver.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/ParseDriver.scala
index 7e1fcfefc64a5ae2120697e3bffbebffb11701e0..09598ffe770c6d0ad94dd340b0dda512cb5de440 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/ParseDriver.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/ParseDriver.scala
@@ -26,6 +26,7 @@ import org.apache.spark.sql.catalyst.{FunctionIdentifier, TableIdentifier}
import org.apache.spark.sql.catalyst.expressions.Expression
import org.apache.spark.sql.catalyst.plans.logical.LogicalPlan
import org.apache.spark.sql.catalyst.trees.Origin
+import org.apache.spark.sql.internal.SQLConf
import org.apache.spark.sql.types.{DataType, StructType}
/**
@@ -121,8 +122,13 @@ abstract class AbstractSqlParser extends ParserInterface with Logging {
/**
* Concrete SQL parser for Catalyst-only SQL statements.
*/
+class CatalystSqlParser(conf: SQLConf) extends AbstractSqlParser {
+ val astBuilder = new AstBuilder(conf)
+}
+
+/** For test-only. */
object CatalystSqlParser extends AbstractSqlParser {
- val astBuilder = new AstBuilder
+ val astBuilder = new AstBuilder(new SQLConf())
}
/**
diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ExpressionParserSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ExpressionParserSuite.scala
index ac7325257a15ab906084c608e07d764cb61cdb39..45f9f72dccc4517b92d538a060f58462386d0f30 100644
--- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ExpressionParserSuite.scala
+++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ExpressionParserSuite.scala
@@ -167,12 +167,12 @@ class ExpressionParserSuite extends PlanTest {
}
test("like expressions with ESCAPED_STRING_LITERALS = true") {
- val parser = CatalystSqlParser
- withSQLConf(SQLConf.ESCAPED_STRING_LITERALS.key -> "true") {
- assertEqual("a rlike '^\\x20[\\x20-\\x23]+$'", 'a rlike "^\\x20[\\x20-\\x23]+$", parser)
- assertEqual("a rlike 'pattern\\\\'", 'a rlike "pattern\\\\", parser)
- assertEqual("a rlike 'pattern\\t\\n'", 'a rlike "pattern\\t\\n", parser)
- }
+ val conf = new SQLConf()
+ conf.setConfString(SQLConf.ESCAPED_STRING_LITERALS.key, "true")
+ val parser = new CatalystSqlParser(conf)
+ assertEqual("a rlike '^\\x20[\\x20-\\x23]+$'", 'a rlike "^\\x20[\\x20-\\x23]+$", parser)
+ assertEqual("a rlike 'pattern\\\\'", 'a rlike "pattern\\\\", parser)
+ assertEqual("a rlike 'pattern\\t\\n'", 'a rlike "pattern\\t\\n", parser)
}
test("is null expressions") {
@@ -435,85 +435,86 @@ class ExpressionParserSuite extends PlanTest {
}
test("strings") {
- val parser = CatalystSqlParser
Seq(true, false).foreach { escape =>
- withSQLConf(SQLConf.ESCAPED_STRING_LITERALS.key -> escape.toString) {
- // tests that have same result whatever the conf is
- // Single Strings.
- assertEqual("\"hello\"", "hello", parser)
- assertEqual("'hello'", "hello", parser)
-
- // Multi-Strings.
- assertEqual("\"hello\" 'world'", "helloworld", parser)
- assertEqual("'hello' \" \" 'world'", "hello world", parser)
-
- // 'LIKE' string literals. Notice that an escaped '%' is the same as an escaped '\' and a
- // regular '%'; to get the correct result you need to add another escaped '\'.
- // TODO figure out if we shouldn't change the ParseUtils.unescapeSQLString method?
- assertEqual("'pattern%'", "pattern%", parser)
- assertEqual("'no-pattern\\%'", "no-pattern\\%", parser)
-
- // tests that have different result regarding the conf
- if (escape) {
- // When SQLConf.ESCAPED_STRING_LITERALS is enabled, string literal parsing fallbacks to
- // Spark 1.6 behavior.
-
- // 'LIKE' string literals.
- assertEqual("'pattern\\\\%'", "pattern\\\\%", parser)
- assertEqual("'pattern\\\\\\%'", "pattern\\\\\\%", parser)
-
- // Escaped characters.
- // Unescape string literal "'\\0'" for ASCII NUL (X'00') doesn't work
- // when ESCAPED_STRING_LITERALS is enabled.
- // It is parsed literally.
- assertEqual("'\\0'", "\\0", parser)
-
- // Note: Single quote follows 1.6 parsing behavior when ESCAPED_STRING_LITERALS is
- // enabled.
- val e = intercept[ParseException](parser.parseExpression("'\''"))
- assert(e.message.contains("extraneous input '''"))
-
- // The unescape special characters (e.g., "\\t") for 2.0+ don't work
- // when ESCAPED_STRING_LITERALS is enabled. They are parsed literally.
- assertEqual("'\\\"'", "\\\"", parser) // Double quote
- assertEqual("'\\b'", "\\b", parser) // Backspace
- assertEqual("'\\n'", "\\n", parser) // Newline
- assertEqual("'\\r'", "\\r", parser) // Carriage return
- assertEqual("'\\t'", "\\t", parser) // Tab character
-
- // The unescape Octals for 2.0+ don't work when ESCAPED_STRING_LITERALS is enabled.
- // They are parsed literally.
- assertEqual("'\\110\\145\\154\\154\\157\\041'", "\\110\\145\\154\\154\\157\\041", parser)
- // The unescape Unicode for 2.0+ doesn't work when ESCAPED_STRING_LITERALS is enabled.
- // They are parsed literally.
- assertEqual("'\\u0057\\u006F\\u0072\\u006C\\u0064\\u0020\\u003A\\u0029'",
- "\\u0057\\u006F\\u0072\\u006C\\u0064\\u0020\\u003A\\u0029", parser)
- } else {
- // Default behavior
-
- // 'LIKE' string literals.
- assertEqual("'pattern\\\\%'", "pattern\\%", parser)
- assertEqual("'pattern\\\\\\%'", "pattern\\\\%", parser)
-
- // Escaped characters.
- // See: http://dev.mysql.com/doc/refman/5.7/en/string-literals.html
- assertEqual("'\\0'", "\u0000", parser) // ASCII NUL (X'00')
- assertEqual("'\\''", "\'", parser) // Single quote
- assertEqual("'\\\"'", "\"", parser) // Double quote
- assertEqual("'\\b'", "\b", parser) // Backspace
- assertEqual("'\\n'", "\n", parser) // Newline
- assertEqual("'\\r'", "\r", parser) // Carriage return
- assertEqual("'\\t'", "\t", parser) // Tab character
- assertEqual("'\\Z'", "\u001A", parser) // ASCII 26 - CTRL + Z (EOF on windows)
-
- // Octals
- assertEqual("'\\110\\145\\154\\154\\157\\041'", "Hello!", parser)
-
- // Unicode
- assertEqual("'\\u0057\\u006F\\u0072\\u006C\\u0064\\u0020\\u003A\\u0029'", "World :)",
- parser)
- }
+ val conf = new SQLConf()
+ conf.setConfString(SQLConf.ESCAPED_STRING_LITERALS.key, escape.toString)
+ val parser = new CatalystSqlParser(conf)
+
+ // tests that have same result whatever the conf is
+ // Single Strings.
+ assertEqual("\"hello\"", "hello", parser)
+ assertEqual("'hello'", "hello", parser)
+
+ // Multi-Strings.
+ assertEqual("\"hello\" 'world'", "helloworld", parser)
+ assertEqual("'hello' \" \" 'world'", "hello world", parser)
+
+ // 'LIKE' string literals. Notice that an escaped '%' is the same as an escaped '\' and a
+ // regular '%'; to get the correct result you need to add another escaped '\'.
+ // TODO figure out if we shouldn't change the ParseUtils.unescapeSQLString method?
+ assertEqual("'pattern%'", "pattern%", parser)
+ assertEqual("'no-pattern\\%'", "no-pattern\\%", parser)
+
+ // tests that have different result regarding the conf
+ if (escape) {
+ // When SQLConf.ESCAPED_STRING_LITERALS is enabled, string literal parsing fallbacks to
+ // Spark 1.6 behavior.
+
+ // 'LIKE' string literals.
+ assertEqual("'pattern\\\\%'", "pattern\\\\%", parser)
+ assertEqual("'pattern\\\\\\%'", "pattern\\\\\\%", parser)
+
+ // Escaped characters.
+ // Unescape string literal "'\\0'" for ASCII NUL (X'00') doesn't work
+ // when ESCAPED_STRING_LITERALS is enabled.
+ // It is parsed literally.
+ assertEqual("'\\0'", "\\0", parser)
+
+ // Note: Single quote follows 1.6 parsing behavior when ESCAPED_STRING_LITERALS is enabled.
+ val e = intercept[ParseException](parser.parseExpression("'\''"))
+ assert(e.message.contains("extraneous input '''"))
+
+ // The unescape special characters (e.g., "\\t") for 2.0+ don't work
+ // when ESCAPED_STRING_LITERALS is enabled. They are parsed literally.
+ assertEqual("'\\\"'", "\\\"", parser) // Double quote
+ assertEqual("'\\b'", "\\b", parser) // Backspace
+ assertEqual("'\\n'", "\\n", parser) // Newline
+ assertEqual("'\\r'", "\\r", parser) // Carriage return
+ assertEqual("'\\t'", "\\t", parser) // Tab character
+
+ // The unescape Octals for 2.0+ don't work when ESCAPED_STRING_LITERALS is enabled.
+ // They are parsed literally.
+ assertEqual("'\\110\\145\\154\\154\\157\\041'", "\\110\\145\\154\\154\\157\\041", parser)
+ // The unescape Unicode for 2.0+ doesn't work when ESCAPED_STRING_LITERALS is enabled.
+ // They are parsed literally.
+ assertEqual("'\\u0057\\u006F\\u0072\\u006C\\u0064\\u0020\\u003A\\u0029'",
+ "\\u0057\\u006F\\u0072\\u006C\\u0064\\u0020\\u003A\\u0029", parser)
+ } else {
+ // Default behavior
+
+ // 'LIKE' string literals.
+ assertEqual("'pattern\\\\%'", "pattern\\%", parser)
+ assertEqual("'pattern\\\\\\%'", "pattern\\\\%", parser)
+
+ // Escaped characters.
+ // See: http://dev.mysql.com/doc/refman/5.7/en/string-literals.html
+ assertEqual("'\\0'", "\u0000", parser) // ASCII NUL (X'00')
+ assertEqual("'\\''", "\'", parser) // Single quote
+ assertEqual("'\\\"'", "\"", parser) // Double quote
+ assertEqual("'\\b'", "\b", parser) // Backspace
+ assertEqual("'\\n'", "\n", parser) // Newline
+ assertEqual("'\\r'", "\r", parser) // Carriage return
+ assertEqual("'\\t'", "\t", parser) // Tab character
+ assertEqual("'\\Z'", "\u001A", parser) // ASCII 26 - CTRL + Z (EOF on windows)
+
+ // Octals
+ assertEqual("'\\110\\145\\154\\154\\157\\041'", "Hello!", parser)
+
+ // Unicode
+ assertEqual("'\\u0057\\u006F\\u0072\\u006C\\u0064\\u0020\\u003A\\u0029'", "World :)",
+ parser)
}
+
}
}
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/execution/SparkSqlParser.scala b/sql/core/src/main/scala/org/apache/spark/sql/execution/SparkSqlParser.scala
index 618d027d8dc07bb81cf710c56aa8a7ec2bbe216c..2f8e416e7df1bea4d5c9f8a3fb7d73ca5c1482fe 100644
--- a/sql/core/src/main/scala/org/apache/spark/sql/execution/SparkSqlParser.scala
+++ b/sql/core/src/main/scala/org/apache/spark/sql/execution/SparkSqlParser.scala
@@ -39,11 +39,10 @@ import org.apache.spark.sql.types.StructType
/**
* Concrete parser for Spark SQL statements.
*/
-class SparkSqlParser extends AbstractSqlParser {
+class SparkSqlParser(conf: SQLConf) extends AbstractSqlParser {
+ val astBuilder = new SparkSqlAstBuilder(conf)
- val astBuilder = new SparkSqlAstBuilder
-
- private val substitutor = new VariableSubstitution
+ private val substitutor = new VariableSubstitution(conf)
protected override def parse[T](command: String)(toResult: SqlBaseParser => T): T = {
super.parse(substitutor.substitute(command))(toResult)
@@ -53,11 +52,9 @@ class SparkSqlParser extends AbstractSqlParser {
/**
* Builder that converts an ANTLR ParseTree into a LogicalPlan/Expression/TableIdentifier.
*/
-class SparkSqlAstBuilder extends AstBuilder {
+class SparkSqlAstBuilder(conf: SQLConf) extends AstBuilder(conf) {
import org.apache.spark.sql.catalyst.parser.ParserUtils._
- private def conf: SQLConf = SQLConf.get
-
/**
* Create a [[SetCommand]] logical plan.
*
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/functions.scala b/sql/core/src/main/scala/org/apache/spark/sql/functions.scala
index a5e4a444f33be2879c2bcf39075e1cd44b26c416..0c7b483f5c83647b0dd8082f819fb9c179b262a3 100644
--- a/sql/core/src/main/scala/org/apache/spark/sql/functions.scala
+++ b/sql/core/src/main/scala/org/apache/spark/sql/functions.scala
@@ -32,6 +32,7 @@ import org.apache.spark.sql.catalyst.expressions.aggregate._
import org.apache.spark.sql.catalyst.plans.logical.{HintInfo, ResolvedHint}
import org.apache.spark.sql.execution.SparkSqlParser
import org.apache.spark.sql.expressions.UserDefinedFunction
+import org.apache.spark.sql.internal.SQLConf
import org.apache.spark.sql.types._
import org.apache.spark.util.Utils
@@ -1275,7 +1276,7 @@ object functions {
*/
def expr(expr: String): Column = {
val parser = SparkSession.getActiveSession.map(_.sessionState.sqlParser).getOrElse {
- new SparkSqlParser
+ new SparkSqlParser(new SQLConf)
}
Column(parser.parseExpression(expr))
}
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/internal/BaseSessionStateBuilder.scala b/sql/core/src/main/scala/org/apache/spark/sql/internal/BaseSessionStateBuilder.scala
index 72d0ddc62303a3a48fbe2493e578a4e6d74aaa75..267f76217df84cbd2a7569df86138754a2cfc6e5 100644
--- a/sql/core/src/main/scala/org/apache/spark/sql/internal/BaseSessionStateBuilder.scala
+++ b/sql/core/src/main/scala/org/apache/spark/sql/internal/BaseSessionStateBuilder.scala
@@ -114,7 +114,7 @@ abstract class BaseSessionStateBuilder(
* Note: this depends on the `conf` field.
*/
protected lazy val sqlParser: ParserInterface = {
- extensions.buildParser(session, new SparkSqlParser)
+ extensions.buildParser(session, new SparkSqlParser(conf))
}
/**
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/internal/VariableSubstitution.scala b/sql/core/src/main/scala/org/apache/spark/sql/internal/VariableSubstitution.scala
index 2b9c574aaaf0cb7dafe3de17c4447051d7ae0fb9..4e7c813be9922e7aab32610ae18d95ac2464bf9c 100644
--- a/sql/core/src/main/scala/org/apache/spark/sql/internal/VariableSubstitution.scala
+++ b/sql/core/src/main/scala/org/apache/spark/sql/internal/VariableSubstitution.scala
@@ -25,9 +25,7 @@ import org.apache.spark.internal.config._
*
* Variable substitution is controlled by `SQLConf.variableSubstituteEnabled`.
*/
-class VariableSubstitution {
-
- private def conf = SQLConf.get
+class VariableSubstitution(conf: SQLConf) {
private val provider = new ConfigProvider {
override def get(key: String): Option[String] = Option(conf.getConfString(key, ""))
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/SparkSqlParserSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/SparkSqlParserSuite.scala
index 2e29fa43f73d9596126817eb9de297b498fe3d24..d238c76fbeeffff631c04826e38317133d66eb09 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/SparkSqlParserSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/SparkSqlParserSuite.scala
@@ -37,7 +37,8 @@ import org.apache.spark.sql.types.{IntegerType, LongType, StringType, StructType
*/
class SparkSqlParserSuite extends AnalysisTest {
- private lazy val parser = new SparkSqlParser
+ val newConf = new SQLConf
+ private lazy val parser = new SparkSqlParser(newConf)
/**
* Normalizes plans:
@@ -284,7 +285,6 @@ class SparkSqlParserSuite extends AnalysisTest {
}
test("query organization") {
- val conf = SQLConf.get
// Test all valid combinations of order by/sort by/distribute by/cluster by/limit/windows
val baseSql = "select * from t"
val basePlan =
@@ -293,20 +293,20 @@ class SparkSqlParserSuite extends AnalysisTest {
assertEqual(s"$baseSql distribute by a, b",
RepartitionByExpression(UnresolvedAttribute("a") :: UnresolvedAttribute("b") :: Nil,
basePlan,
- numPartitions = conf.numShufflePartitions))
+ numPartitions = newConf.numShufflePartitions))
assertEqual(s"$baseSql distribute by a sort by b",
Sort(SortOrder(UnresolvedAttribute("b"), Ascending) :: Nil,
global = false,
RepartitionByExpression(UnresolvedAttribute("a") :: Nil,
basePlan,
- numPartitions = conf.numShufflePartitions)))
+ numPartitions = newConf.numShufflePartitions)))
assertEqual(s"$baseSql cluster by a, b",
Sort(SortOrder(UnresolvedAttribute("a"), Ascending) ::
SortOrder(UnresolvedAttribute("b"), Ascending) :: Nil,
global = false,
RepartitionByExpression(UnresolvedAttribute("a") :: UnresolvedAttribute("b") :: Nil,
basePlan,
- numPartitions = conf.numShufflePartitions)))
+ numPartitions = newConf.numShufflePartitions)))
}
test("pipeline concatenation") {
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/DDLCommandSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/DDLCommandSuite.scala
index 750574830381f5de6a6268a648e46b375e42aed6..5643c58d9f847474f5b7d1ed9090e33f6056e65e 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/execution/command/DDLCommandSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/execution/command/DDLCommandSuite.scala
@@ -29,13 +29,13 @@ import org.apache.spark.sql.catalyst.plans.PlanTest
import org.apache.spark.sql.catalyst.plans.logical.Project
import org.apache.spark.sql.execution.SparkSqlParser
import org.apache.spark.sql.execution.datasources.CreateTable
-import org.apache.spark.sql.internal.HiveSerDe
+import org.apache.spark.sql.internal.{HiveSerDe, SQLConf}
import org.apache.spark.sql.types.{IntegerType, StringType, StructField, StructType}
// TODO: merge this with DDLSuite (SPARK-14441)
class DDLCommandSuite extends PlanTest {
- private lazy val parser = new SparkSqlParser
+ private lazy val parser = new SparkSqlParser(new SQLConf)
private def assertUnsupported(sql: String, containsThesePhrases: Seq[String] = Seq()): Unit = {
val e = intercept[ParseException] {
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/internal/VariableSubstitutionSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/internal/VariableSubstitutionSuite.scala
index c5e5b70e213355036522c34585e336ff9fbacf44..d5a946aeaac31e95475ac94c2923db41f776ff98 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/internal/VariableSubstitutionSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/internal/VariableSubstitutionSuite.scala
@@ -18,11 +18,12 @@
package org.apache.spark.sql.internal
import org.apache.spark.SparkFunSuite
-import org.apache.spark.sql.catalyst.plans.PlanTest
+import org.apache.spark.sql.AnalysisException
-class VariableSubstitutionSuite extends SparkFunSuite with PlanTest {
+class VariableSubstitutionSuite extends SparkFunSuite {
- private lazy val sub = new VariableSubstitution
+ private lazy val conf = new SQLConf
+ private lazy val sub = new VariableSubstitution(conf)
test("system property") {
System.setProperty("varSubSuite.var", "abcd")
@@ -34,26 +35,26 @@ class VariableSubstitutionSuite extends SparkFunSuite with PlanTest {
}
test("Spark configuration variable") {
- withSQLConf("some-random-string-abcd" -> "1234abcd") {
- assert(sub.substitute("${hiveconf:some-random-string-abcd}") == "1234abcd")
- assert(sub.substitute("${sparkconf:some-random-string-abcd}") == "1234abcd")
- assert(sub.substitute("${spark:some-random-string-abcd}") == "1234abcd")
- assert(sub.substitute("${some-random-string-abcd}") == "1234abcd")
- }
+ conf.setConfString("some-random-string-abcd", "1234abcd")
+ assert(sub.substitute("${hiveconf:some-random-string-abcd}") == "1234abcd")
+ assert(sub.substitute("${sparkconf:some-random-string-abcd}") == "1234abcd")
+ assert(sub.substitute("${spark:some-random-string-abcd}") == "1234abcd")
+ assert(sub.substitute("${some-random-string-abcd}") == "1234abcd")
}
test("multiple substitutes") {
val q = "select ${bar} ${foo} ${doo} this is great"
- withSQLConf("bar" -> "1", "foo" -> "2", "doo" -> "3") {
- assert(sub.substitute(q) == "select 1 2 3 this is great")
- }
+ conf.setConfString("bar", "1")
+ conf.setConfString("foo", "2")
+ conf.setConfString("doo", "3")
+ assert(sub.substitute(q) == "select 1 2 3 this is great")
}
test("test nested substitutes") {
val q = "select ${bar} ${foo} this is great"
- withSQLConf("bar" -> "1", "foo" -> "${bar}") {
- assert(sub.substitute(q) == "select 1 1 this is great")
- }
+ conf.setConfString("bar", "1")
+ conf.setConfString("foo", "${bar}")
+ assert(sub.substitute(q) == "select 1 1 this is great")
}
}