diff --git a/python/pyspark/sql/functions.py b/python/pyspark/sql/functions.py
index 45d6bf944b702e7d4b585ffc1f800ed58fd2bf2d..7fa3fd2de7ddf31ad0c8eb199d216d091cfa582c 100644
--- a/python/pyspark/sql/functions.py
+++ b/python/pyspark/sql/functions.py
@@ -112,11 +112,8 @@ _functions_1_4 = {
'sinh': 'Computes the hyperbolic sine of the given value.',
'tan': 'Computes the tangent of the given value.',
'tanh': 'Computes the hyperbolic tangent of the given value.',
- 'toDegrees': 'Converts an angle measured in radians to an approximately equivalent angle ' +
- 'measured in degrees.',
- 'toRadians': 'Converts an angle measured in degrees to an approximately equivalent angle ' +
- 'measured in radians.',
-
+ 'toDegrees': '.. note:: Deprecated in 2.1, use degrees instead.',
+ 'toRadians': '.. note:: Deprecated in 2.1, use radians instead.',
'bitwiseNOT': 'Computes bitwise not.',
}
@@ -135,7 +132,15 @@ _functions_1_6 = {
'kurtosis': 'Aggregate function: returns the kurtosis of the values in a group.',
'collect_list': 'Aggregate function: returns a list of objects with duplicates.',
'collect_set': 'Aggregate function: returns a set of objects with duplicate elements' +
- ' eliminated.'
+ ' eliminated.',
+}
+
+_functions_2_1 = {
+ # unary math functions
+ 'degrees': 'Converts an angle measured in radians to an approximately equivalent angle ' +
+ 'measured in degrees.',
+ 'radians': 'Converts an angle measured in degrees to an approximately equivalent angle ' +
+ 'measured in radians.',
}
# math functions that take two arguments as input
@@ -182,21 +187,31 @@ for _name, _doc in _window_functions.items():
globals()[_name] = since(1.6)(_create_window_function(_name, _doc))
for _name, _doc in _functions_1_6.items():
globals()[_name] = since(1.6)(_create_function(_name, _doc))
+for _name, _doc in _functions_2_1.items():
+ globals()[_name] = since(2.1)(_create_function(_name, _doc))
del _name, _doc
@since(1.3)
def approxCountDistinct(col, rsd=None):
+ """
+ .. note:: Deprecated in 2.1, use approx_count_distinct instead.
+ """
+ return approx_count_distinct(col, rsd)
+
+
+@since(2.1)
+def approx_count_distinct(col, rsd=None):
"""Returns a new :class:`Column` for approximate distinct count of ``col``.
- >>> df.agg(approxCountDistinct(df.age).alias('c')).collect()
+ >>> df.agg(approx_count_distinct(df.age).alias('c')).collect()
[Row(c=2)]
"""
sc = SparkContext._active_spark_context
if rsd is None:
- jc = sc._jvm.functions.approxCountDistinct(_to_java_column(col))
+ jc = sc._jvm.functions.approx_count_distinct(_to_java_column(col))
else:
- jc = sc._jvm.functions.approxCountDistinct(_to_java_column(col), rsd)
+ jc = sc._jvm.functions.approx_count_distinct(_to_java_column(col), rsd)
return Column(jc)
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 3bc1c5b90031d56fe84a2b6ff27399e3c75af3aa..40f82d895d43b3d0aad04e7dcacd1a8ad4206379 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
@@ -182,13 +182,43 @@ object functions {
// Aggregate functions
//////////////////////////////////////////////////////////////////////////////////////////////
+ /**
+ * @group agg_funcs
+ * @since 1.3.0
+ */
+ @deprecated("Use approx_count_distinct", "2.1.0")
+ def approxCountDistinct(e: Column): Column = approx_count_distinct(e)
+
+ /**
+ * @group agg_funcs
+ * @since 1.3.0
+ */
+ @deprecated("Use approx_count_distinct", "2.1.0")
+ def approxCountDistinct(columnName: String): Column = approx_count_distinct(columnName)
+
+ /**
+ * @group agg_funcs
+ * @since 1.3.0
+ */
+ @deprecated("Use approx_count_distinct", "2.1.0")
+ def approxCountDistinct(e: Column, rsd: Double): Column = approx_count_distinct(e, rsd)
+
+ /**
+ * @group agg_funcs
+ * @since 1.3.0
+ */
+ @deprecated("Use approx_count_distinct", "2.1.0")
+ def approxCountDistinct(columnName: String, rsd: Double): Column = {
+ approx_count_distinct(Column(columnName), rsd)
+ }
+
/**
* Aggregate function: returns the approximate number of distinct items in a group.
*
* @group agg_funcs
- * @since 1.3.0
+ * @since 2.1.0
*/
- def approxCountDistinct(e: Column): Column = withAggregateFunction {
+ def approx_count_distinct(e: Column): Column = withAggregateFunction {
HyperLogLogPlusPlus(e.expr)
}
@@ -196,9 +226,9 @@ object functions {
* Aggregate function: returns the approximate number of distinct items in a group.
*
* @group agg_funcs
- * @since 1.3.0
+ * @since 2.1.0
*/
- def approxCountDistinct(columnName: String): Column = approxCountDistinct(column(columnName))
+ def approx_count_distinct(columnName: String): Column = approx_count_distinct(column(columnName))
/**
* Aggregate function: returns the approximate number of distinct items in a group.
@@ -206,9 +236,9 @@ object functions {
* @param rsd maximum estimation error allowed (default = 0.05)
*
* @group agg_funcs
- * @since 1.3.0
+ * @since 2.1.0
*/
- def approxCountDistinct(e: Column, rsd: Double): Column = withAggregateFunction {
+ def approx_count_distinct(e: Column, rsd: Double): Column = withAggregateFunction {
HyperLogLogPlusPlus(e.expr, rsd, 0, 0)
}
@@ -218,10 +248,10 @@ object functions {
* @param rsd maximum estimation error allowed (default = 0.05)
*
* @group agg_funcs
- * @since 1.3.0
+ * @since 2.1.0
*/
- def approxCountDistinct(columnName: String, rsd: Double): Column = {
- approxCountDistinct(Column(columnName), rsd)
+ def approx_count_distinct(columnName: String, rsd: Double): Column = {
+ approx_count_distinct(Column(columnName), rsd)
}
/**
@@ -1949,37 +1979,65 @@ object functions {
*/
def tanh(columnName: String): Column = tanh(Column(columnName))
+ /**
+ * @group math_funcs
+ * @since 1.4.0
+ */
+ @deprecated("Use degrees", "2.1.0")
+ def toDegrees(e: Column): Column = degrees(e)
+
+ /**
+ * @group math_funcs
+ * @since 1.4.0
+ */
+ @deprecated("Use degrees", "2.1.0")
+ def toDegrees(columnName: String): Column = degrees(Column(columnName))
+
/**
* Converts an angle measured in radians to an approximately equivalent angle measured in degrees.
*
* @group math_funcs
- * @since 1.4.0
+ * @since 2.1.0
*/
- def toDegrees(e: Column): Column = withExpr { ToDegrees(e.expr) }
+ def degrees(e: Column): Column = withExpr { ToDegrees(e.expr) }
/**
* Converts an angle measured in radians to an approximately equivalent angle measured in degrees.
*
+ * @group math_funcs
+ * @since 2.1.0
+ */
+ def degrees(columnName: String): Column = degrees(Column(columnName))
+
+ /**
+ * @group math_funcs
+ * @since 1.4.0
+ */
+ @deprecated("Use radians", "2.1.0")
+ def toRadians(e: Column): Column = radians(e)
+
+ /**
* @group math_funcs
* @since 1.4.0
*/
- def toDegrees(columnName: String): Column = toDegrees(Column(columnName))
+ @deprecated("Use radians", "2.1.0")
+ def toRadians(columnName: String): Column = radians(Column(columnName))
/**
* Converts an angle measured in degrees to an approximately equivalent angle measured in radians.
*
* @group math_funcs
- * @since 1.4.0
+ * @since 2.1.0
*/
- def toRadians(e: Column): Column = withExpr { ToRadians(e.expr) }
+ def radians(e: Column): Column = withExpr { ToRadians(e.expr) }
/**
* Converts an angle measured in degrees to an approximately equivalent angle measured in radians.
*
* @group math_funcs
- * @since 1.4.0
+ * @since 2.1.0
*/
- def toRadians(columnName: String): Column = toRadians(Column(columnName))
+ def radians(columnName: String): Column = radians(Column(columnName))
//////////////////////////////////////////////////////////////////////////////////////////////
// Misc functions
@@ -3096,5 +3154,4 @@ object functions {
def callUDF(udfName: String, cols: Column*): Column = withExpr {
UnresolvedFunction(udfName, cols.map(_.expr), isDistinct = false)
}
-
}
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/DataFrameWindowSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/DataFrameWindowSuite.scala
index c6f8c3ad3fc937d9cee9cbe2a6a9f73010fb0da1..c2b47cae8f4c45c010023671f45d1dc6bdcbbeee 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/DataFrameWindowSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/DataFrameWindowSuite.scala
@@ -228,7 +228,7 @@ class DataFrameWindowSuite extends QueryTest with SharedSQLContext {
$"key",
var_pop($"value").over(window),
var_samp($"value").over(window),
- approxCountDistinct($"value").over(window)),
+ approx_count_distinct($"value").over(window)),
Seq.fill(4)(Row("a", 1.0d / 4.0d, 1.0d / 3.0d, 2))
++ Seq.fill(3)(Row("b", 2.0d / 3.0d, 1.0d, 3)))
}
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/MathExpressionsSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/MathExpressionsSuite.scala
index 0de7f2321f39834e1eeabfcfa8a291b270646277..6944c6f84817978d980dcb1bb18a31026e9b3efc 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/MathExpressionsSuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/MathExpressionsSuite.scala
@@ -148,19 +148,19 @@ class MathExpressionsSuite extends QueryTest with SharedSQLContext {
testOneToOneMathFunction(tanh, math.tanh)
}
- test("toDegrees") {
- testOneToOneMathFunction(toDegrees, math.toDegrees)
+ test("degrees") {
+ testOneToOneMathFunction(degrees, math.toDegrees)
checkAnswer(
sql("SELECT degrees(0), degrees(1), degrees(1.5)"),
- Seq((1, 2)).toDF().select(toDegrees(lit(0)), toDegrees(lit(1)), toDegrees(lit(1.5)))
+ Seq((1, 2)).toDF().select(degrees(lit(0)), degrees(lit(1)), degrees(lit(1.5)))
)
}
- test("toRadians") {
- testOneToOneMathFunction(toRadians, math.toRadians)
+ test("radians") {
+ testOneToOneMathFunction(radians, math.toRadians)
checkAnswer(
sql("SELECT radians(0), radians(1), radians(1.5)"),
- Seq((1, 2)).toDF().select(toRadians(lit(0)), toRadians(lit(1)), toRadians(lit(1.5)))
+ Seq((1, 2)).toDF().select(radians(lit(0)), radians(lit(1)), radians(lit(1.5)))
)
}