Question

我想知道如何使用JAVA从Spark SQL中的域特定语言（DSL）函数调用UDF函数。

我有UDF功能（仅举例）：

UDF2 equals = new UDF2<String, String, Boolean>() {
   @Override
   public Boolean call(String first, String second) throws Exception {
       return first.equals(second);
   }
};

我已将其注册到sqlContext

sqlContext.udf().register("equals", equals, DataTypes.BooleanType);

当我运行以下查询时，我的UDF被调用，我得到一个结果。

sqlContext.sql("SELECT p0.value FROM values p0 WHERE equals(p0.value, 'someString')");

我会在Spark SQL中使用域特定语言的功能转换此查询，我不知道该怎么做。

valuesDF.select("value").where(???);

我发现存在callUDF（）函数，其中一个参数是Function2 fnctn而不是UDF2。我如何使用DSL中的UDF和函数？

Answer 1

我找到了一个我满意的解决方案。可以将UDF称为列条件，例如：

valuesDF.filter("equals(columnName, 'someString')").select("columnName");

但我仍然想知道是否可以直接调用UDF。

编辑：

顺便说一下，可以直接调用udf，例如：

df.where(callUdf("equals", scala.collection.JavaConversions.asScalaBuffer(
                        Arrays.asList(col("columnName"), col("otherColumnName"))
                    ).seq())).select("columnName");

导入org.apache.spark。sql。函数是必需的。

Answer 2

查询数据帧时，您应该能够使用以下内容执行UDF：

sourceDf.filter(equals(col("columnName"), "someString")).select("columnName")

其中col（“columnName”）是您要比较的列。

Answer 3

这是工作代码示例。它适用于Spark 1.5.x和1.6.x.从管道转换器中调用UDF的技巧是使用DataFrame上的sqlContext（）来注册UDF

@Test
public void test() {
    // https://issues.apache.org/jira/browse/SPARK-12484
    logger.info("BEGIN");

    DataFrame df = createData();        
    final String tableName = "myTable";
    sqlContext.registerDataFrameAsTable(df, tableName);

    logger.info("print schema");
    df.printSchema();
    logger.info("original data before we applied UDF");
    df.show();

    MyUDF udf = new MyUDF();
    final String udfName = "myUDF";
    sqlContext.udf().register(udfName, udf, DataTypes.StringType);

    String fmt = "SELECT *, %s(%s) as transformedByUDF FROM %s";
    String stmt = String.format(fmt, udfName, tableName+".labelStr", tableName); 
    logger.info("AEDWIP stmt:{}", stmt);
    DataFrame udfDF = sqlContext.sql(stmt);
    Row[] results = udfDF.head(3);
    for (Row row : results) {
        logger.info("row returned by applying UDF {}", row);
    }

    logger.info("AEDWIP udfDF schema");
    udfDF.printSchema();
    logger.info("AEDWIP udfDF data");
    udfDF.show();


    logger.info("END");
}

DataFrame createData() {
    Features f1 = new Features(1, category1);
    Features f2 = new Features(2, category2);
    ArrayList<Features> data = new ArrayList<Features>(2);
    data.add(f1);
    data.add(f2);
    //JavaRDD<Features> rdd = javaSparkContext.parallelize(Arrays.asList(f1, f2));
    JavaRDD<Features> rdd = javaSparkContext.parallelize(data);
    DataFrame df = sqlContext.createDataFrame(rdd, Features.class);
    return df;
}

class MyUDF implements UDF1<String, String> {
    private static final long serialVersionUID = 1L;

    @Override
    public String call(String s) throws Exception {
        logger.info("AEDWIP s:{}", s);
        String ret = s.equalsIgnoreCase(category1) ?  category1 : category3;
        return ret;
    }
}

public class Features implements Serializable{
    private static final long serialVersionUID = 1L;
    int id;
    String labelStr;

    Features(int id, String l) {
        this.id = id;
        this.labelStr = l;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getLabelStr() {
        return labelStr;
    }

    public void setLabelStr(String labelStr) {
        this.labelStr = labelStr;
    }
}

this is the output

+---+--------+
| id|labelStr|
+---+--------+
|  1|   noise|
|  2|     ack|
+---+--------+

root
 |-- id: integer (nullable = false)
 |-- labelStr: string (nullable = true)
 |-- transformedByUDF: string (nullable = true)

+---+--------+----------------+
| id|labelStr|transformedByUDF|
+---+--------+----------------+
|  1|   noise|           noise|
|  2|     ack|          signal|
+---+--------+----------------+

Spark SQL：如何使用JAVA从DataFrame操作调用UDF

3 个答案: