He intentado tanto, pero funciona de la misma

ejemplo

val items =  List(1, 2, 3)

usando el filtro

employees.filter($"emp_id".isin(items:_*)).show

el uso de donde

employees.where($"emp_id".isin(items:_*)).show

Resultado es el mismo para ambos

+------+------+------+-------+------+-------+
|EMP_ID|F_NAME|SALARY|DEPT_ID|L_NAME|MANAGER|
+------+------+------+-------+------+-------+
|     6|    E6|  2000|      4|    L6|      2|
|     7|    E7|  3000|      4|    L7|      1|
|     8|    E8|  4000|      2|    L8|      2|
|     9|    E9|  1500|      2|    L9|      1|
|    10|   E10|  1000|      2|   L10|      1|
|     4|    E4|   400|      3|    L4|      1|
|     2|    E2|   200|      1|    L2|      1|
|     3|    E3|   700|      2|    L3|      2|
|     5|    E5|   300|      2|    L5|      2|
+------+------+------+-------+------+-------+
InformationsquelleAutor Ishan | 2015-11-24

3 Comentarios

  1. 28

    , donde documentación:

    Filtros filas con la condición dada. Este es un alias para el filtro.

    filter es simplemente el estándar de la Scala (y FP en general) nombre de dicha función, y where es para las personas que prefieren SQL.

  2. 2

    sólo FYI,

    maxTsunx.filter(r => r.get(0) == 1)

    maxTsunx.where(col("ticker_id")===1)

    o

    maxTsunx.filter(col("ticker_id")===1)

    Que en el primer caso, pasando de función a función de filtro

    En el segundo caso, la transferencia de la condición de la expresión (string o tipo de columna) para filtrar o donde la función.
    Plan físico 2 también es posible mediante la sustitución de where con función de filtro.

  3. 1

    Se relaciona también con la Chispa de optimización. Mirar a corto ejemplo:
    Gran parquet archivo en HDFS con la estructura y los datos:

    [hadoop@hdpnn ~]$ hadoop fs -ls /user/tickers/ticks.parquet
    Found 27 items
    drwxr-xr-x   - root root          0 2019-01-16 12:55 /user/tickers/ticks.parquet/ticker_id=1
    drwxr-xr-x   - root root          0 2019-01-16 13:58 /user/tickers/ticks.parquet/ticker_id=10
    drwxr-xr-x   - root root          0 2019-01-16 14:04 /user/tickers/ticks.parquet/ticker_id=11
    drwxr-xr-x   - root root          0 2019-01-16 14:10 /user/tickers/ticks.parquet/ticker_id=12
    ...

    Donde cada partición tiene particiones en el interior (por fecha)

    [hadoop@hdpnn ~]$ hadoop fs -ls /user/tickers/ticks.parquet/ticker_id=1
    Found 6 items
    drwxr-xr-x   - root root          0 2019-01-16 12:55 /user/tickers/ticks.parquet/ticker_id=1/ddate=2019-01-09
    drwxr-xr-x   - root root          0 2019-01-16 12:50 /user/tickers/ticks.parquet/ticker_id=1/ddate=2019-01-10
    drwxr-xr-x   - root root          0 2019-01-16 12:53 /user/tickers/ticks.parquet/ticker_id=1/ddate=2019-01-11
    ...

    Estructura:

    scala> spark.read.parquet("hdfs://hdpnn:9000/user/tickers/ticks.parquet").printSchema
    root
     |-- ticker_id: integer (nullable = true)
     |-- ddate: date (nullable = true)
     |-- db_tsunx: long (nullable = true)
     |-- ask: double (nullable = true)
     |-- bid: double (nullable = true)

    Por ejemplo, usted tiene DS como este:

    val maxTsunx = spark.read.parquet("hdfs://hdpnn:9000/user/tickers/ticks.parquet").select(col("ticker_id"),col("db_tsunx")).groupBy("ticker_id").agg(max("db_tsunx"))

    que contiene max(db_tsunx) para cada ticker_id

    F. E.: usted desea obtener los datos para sólo un ticker de este DS

    Tienes 2 maneras:

    1) maxTsunx.filter(r => r.get(0) == 1)
    2) maxTsunx.where(col("ticker_id")===1)

    y es muy diferente «plano Físico»

    mirar
    1)

        == Physical Plan ==
        *(2) Filter <function1>.apply
        +- *(2) HashAggregate(keys=[ticker_id#37], functions=[max(db_tsunx#39L)], output=[ticker_id#37, max(db_tsunx)#52L])
           +- Exchange hashpartitioning(ticker_id#37, 200)
              +- *(1) HashAggregate(keys=[ticker_id#37], functions=[partial_max(db_tsunx#39L)], output=[ticker_id#37, max#61L])
                 +- *(1) Project [ticker_id#37, db_tsunx#39L]
                    +- *(1) FileScan parquet [db_tsunx#39L,ticker_id#37,ddate#38]    Batched: true, Format: Parquet, 
    Location: InMemoryFileIndex[hdfs://hdpnn:9000/user/tickers/ticks.parquet],
    PartitionCount: 162, 
        PartitionFilters: [], 
        PushedFilters: [], 
        ReadSchema: struct<db_tsunx:bigint>

    2)

    == Physical Plan ==
    *(2) HashAggregate(keys=[ticker_id#84], functions=[max(db_tsunx#86L)], output=[ticker_id#84, max(db_tsunx)#99L])
    +- Exchange hashpartitioning(ticker_id#84, 200)
       +- *(1) HashAggregate(keys=[ticker_id#84], functions=[partial_max(db_tsunx#86L)], output=[ticker_id#84, max#109L])
          +- *(1) Project [ticker_id#84, db_tsunx#86L]
             +- *(1) FileScan parquet [db_tsunx#86L,ticker_id#84,ddate#85] Batched: true, Format: Parquet, 
    Location: InMemoryFileIndex[hdfs://hdpnn:9000/user/tickers/ticks.parquet], 
    PartitionCount: 6, 
    PartitionFilters: [isnotnull(ticker_id#84), (ticker_id#84 = 1)], 
    PushedFilters: [], 
    ReadSchema: struct<db_tsunx:bigint>

    Comparar 162 y 6 y
    PartitionFilters: [],
    PartitionFilters: [isnotnull(ticker_id#84), (ticker_id#84 = 1)],

    Significa que la acción del filtro en los datos de DS y donde ir en el interior de la Chispa y se utilizan para la optimización.

Dejar respuesta

Please enter your comment!
Please enter your name here