web-dev-qa-db-fra.com

Comment vérifier si spark dataframe est vide

Pour le moment, je dois utiliser df.count > 0 pour vérifier si le DataFrame est vide ou non. Mais c'est un peu inefficace. Y a-t-il une meilleure façon de le faire?.

Merci.

PS: Je veux vérifier s'il est vide pour ne sauvegarder que la DataFrame si ce n'est pas vide

apache-sparkapache-spark-sql
72
auxdx

Pour Spark 2.1.0, ma suggestion serait d'utiliser head(n: Int) ou take(n: Int) avec isEmpty, selon l'intention la plus claire.

df.head(1).isEmpty
df.take(1).isEmpty

avec Python équivalent:

len(df.head(1)) == 0  # or bool(df.head(1))
len(df.take(1)) == 0  # or bool(df.take(1))

Utiliser df.first() et df.head() renverra le Java.util.NoSuchElementException si le DataFrame est vide. first() appelle head() directement, qui appelle head(1).head.

def first(): T = head()
def head(): T = head(1).head

head(1) renvoie un tableau. Par conséquent, si vous prenez head sur ce tableau, vous obtenez le Java.util.NoSuchElementException lorsque le champ de données est vide.

def head(n: Int): Array[T] = withAction("head", limit(n).queryExecution)(collectFromPlan)

Ainsi, au lieu d'appeler head(), utilisez head(1) directement pour obtenir le tableau, puis utilisez isEmpty.

take(n) est également équivalent à head(n)...

def take(n: Int): Array[T] = head(n)

Et limit(1).collect() équivaut à head(1) (remarque limit(n).queryExecution dans la méthode head(n: Int),), les éléments suivants sont donc équivalents, du moins d'après ce que je peux dire, et vous avez gagné. Il n'est pas nécessaire d'attraper une exception Java.util.NoSuchElementException lorsque le DataFrame est vide.

df.head(1).isEmpty
df.take(1).isEmpty
df.limit(1).collect().isEmpty

Je sais que c'est une question plus ancienne, j'espère que cela aidera quelqu'un qui utilise une version plus récente de Spark.

104
hulin003

Je dirais qu'il suffit de saisir le sous-jacent RDD. En Scala:

df.rdd.isEmpty

en Python:

df.rdd.isEmpty()

Cela étant dit, tout cela n’appelle que take(1).length, donc ça fera la même chose que Rohan a répondu ... juste peut-être un peu plus explicite?

41
Justin Pihony

Vous pouvez tirer parti des fonctions head() (ou first()) pour voir si le DataFrame comporte une seule ligne. Si c'est le cas, ce n'est pas vide.

13
Rohan Aletty

Si vous faites df.count > 0. Il prend en compte le nombre de partitions sur tous les exécuteurs et les ajoute au pilote. Cela prend du temps lorsque vous avez affaire à des millions de lignes.

La meilleure façon de faire est d'exécuter df.take(1) et de vérifier si sa valeur est nulle. Cela retournera Java.util.NoSuchElementException alors il vaut mieux essayer _ df.take(1).

Le cadre de données renvoie une erreur lorsque take(1) est effectué à la place d'une ligne vide. J'ai mis en évidence les lignes de code spécifiques où l'erreur est générée.

enter image description here

5
Nandakishore

Pour les utilisateurs de Java, vous pouvez utiliser ceci sur un jeu de données:

public boolean isDatasetEmpty(Dataset<Row> ds) {
        boolean isEmpty;
        try {
            isEmpty = ((Row[]) ds.head(1)).length == 0;
        } catch (Exception e) {
            return true;
        }
        return isEmpty;
}

Ceci vérifie tous les scénarios possibles (vide, nul).

3
Abdennacer Lachiheb

Depuis Spark 2.4.0, il y a Dataset.isEmpty .

C'est implémentation c'est:

_def isEmpty: Boolean = 
  withAction("isEmpty", limit(1).groupBy().count().queryExecution) { plan =>
    plan.executeCollect().head.getLong(0) == 0
}
_

Notez qu'un DataFrame n'est plus une classe dans Scala, mais simplement un type alias (probablement modifié avec Spark 2.0):

_type DataFrame = Dataset[Row]
_
2
Beryllium

Si vous utilisez Pypsark, vous pouvez également effectuer les tâches suivantes:

len(df.head(1)) > 0
1
Adelholzener

Dans Scala, vous pouvez utiliser des implicites pour ajouter les méthodes isEmpty() et nonEmpty() de l'API DataFrame, ce qui rendra le code un peu plus agréable à lire.

object DataFrameExtensions {
  implicit def extendedDataFrame(dataFrame: DataFrame): ExtendedDataFrame = 
    new ExtendedDataFrame(dataFrame: DataFrame)

  class ExtendedDataFrame(dataFrame: DataFrame) {
    def isEmpty(): Boolean = {
      Try{dataFrame.first.length != 0} match {
        case Success(_) => false
        case Failure(_) => true 
      }
    }

    def nonEmpty(): Boolean = !isEmpty
  }
}

Ici, d'autres méthodes peuvent également être ajoutées. Pour utiliser la conversion implicite, utilisez import DataFrameExtensions._ dans le fichier dans lequel vous souhaitez utiliser la fonctionnalité étendue. Ensuite, les méthodes peuvent être utilisées directement comme suit:

val df: DataFrame = ...
if (df.isEmpty) {
  // Do something
}
1
Shaido
df1.take(1).length>0

La méthode take renvoie le tableau de lignes. Par conséquent, si la taille du tableau est égale à zéro, il n'y a aucun enregistrement dans df.

0
Gopi A

J'ai trouvé que dans certains cas:

>>>print(type(df))
<class 'pyspark.sql.dataframe.DataFrame'>

>>>df.take(1).isEmpty
'list' object has no attribute 'isEmpty'

il en va de même pour "longueur" ou remplacez take () par head ()

[Solution] pour le problème que nous pouvons utiliser.

>>>df.limit(2).count() > 1
False
0
Shekhar Koirala

Sur PySpark, vous pouvez également utiliser cette bool(df.head(1)) pour obtenir une valeur True sur False

Il retourne False si le cadre de données ne contient aucune ligne.

0
Bose