0 / 0
Go back to the English version of the documentation
Pomijanie danych dla Spark SQL
Last updated: 28 wrz 2023
Pomijanie danych dla Spark SQL

Pomijanie danych może znacząco zwiększyć wydajność zapytań SQL, pomijając nieistotne obiekty danych lub pliki na podstawie metadanych podsumowania powiązanych z każdym obiektem.

Pomijanie danych wykorzystuje bibliotekę Open Source Xskipper do tworzenia, zarządzania i wdrażania indeksów pomijania danych za pomocą środowiska Apache Spark. Patrz Xskipper-An Extensible Data Skipping Framework.

Więcej informacji na temat pracy z Xskipper zawiera:

Oprócz funkcji Open Source w programie Xskipper dostępne są również następujące funkcje:

Pomijanie danych geoprzestrzennych

Można również użyć pomijania danych podczas wykonywania zapytań do zbiorów danych geoprzestrzennych za pomocą funkcji geoprzestrzennych z biblioteki przestrzenno-czasowej.

  • Aby korzystać z pomijania danych w zestawach danych z kolumnami szerokości i długości geograficznej, można gromadzić indeksy min/maks dla kolumn szerokości i długości geograficznej.
  • Pomijanie danych może być używane w zestawach danych z kolumną geometrii (kolumną UDT) za pomocą wbudowanej wtyczki Xskipper.

Następne sekcje przedstawiają pracę z wtyczką geoprzestrzenną.

Konfigurowanie wtyczki geoprzestrzennej

Aby użyć wtyczki, należy załadować odpowiednie implementacje przy użyciu modułu rejestracji. Należy zauważyć, że w aplikacjach IBM Analytics Engine opartych na technologii Apache Spark, a nie na platformie Watson Studio, można używać tylko platformy Scala.

  • Dla Scala:

    import com.ibm.xskipper.stmetaindex.filter.STMetaDataFilterFactory
    import com.ibm.xskipper.stmetaindex.index.STIndexFactory
    import com.ibm.xskipper.stmetaindex.translation.parquet.{STParquetMetaDataTranslator, STParquetMetadatastoreClauseTranslator}
    import io.xskipper._
    
    Registration.addIndexFactory(STIndexFactory)
    Registration.addMetadataFilterFactory(STMetaDataFilterFactory)
    Registration.addClauseTranslator(STParquetMetadatastoreClauseTranslator)
    Registration.addMetaDataTranslator(STParquetMetaDataTranslator)
    
  • W przypadku Python:

    from xskipper import Xskipper
    from xskipper import Registration
    
    Registration.addMetadataFilterFactory(spark, 'com.ibm.xskipper.stmetaindex.filter.STMetaDataFilterFactory')
    Registration.addIndexFactory(spark, 'com.ibm.xskipper.stmetaindex.index.STIndexFactory')
    Registration.addMetaDataTranslator(spark, 'com.ibm.xskipper.stmetaindex.translation.parquet.STParquetMetaDataTranslator')
    Registration.addClauseTranslator(spark, 'com.ibm.xskipper.stmetaindex.translation.parquet.STParquetMetadatastoreClauseTranslator')
    

Budowanie indeksu

Aby zbudować indeks, można użyć interfejsu API języka addCustomIndex . Należy zauważyć, że w aplikacjach IBM Analytics Engine opartych na technologii Apache Spark, a nie na platformie Watson Studio, można używać tylko platformy Scala.

  • Dla Scala:

    import com.ibm.xskipper.stmetaindex.implicits._
    
    // index the dataset
    val xskipper = new Xskipper(spark, dataset_path)
    
    xskipper
      .indexBuilder()
      // using the implicit method defined in the plugin implicits
      .addSTBoundingBoxLocationIndex("location")
      // equivalent
      //.addCustomIndex(STBoundingBoxLocationIndex("location"))
      .build(reader).show(false)
    
  • W przypadku Python:

    xskipper = Xskipper(spark, dataset_path)
    
    # adding the index using the custom index API
    xskipper.indexBuilder() \
            .addCustomIndex("com.ibm.xskipper.stmetaindex.index.STBoundingBoxLocationIndex", ['location'], dict()) \
            .build(reader) \
            .show(10, False)
    

Obsługiwane funkcje

Lista obsługiwanych funkcji geoprzestrzennych obejmuje następujące elementy:

  • ST_Odległość
  • ST_Przecięcia
  • ST_Zawiera
  • ST_Równe
  • ST_Krzyży_krzyżowe
  • Ostatni_dotyk
  • ST_W
  • Narzuty typu ST_Overlaps
  • ST_EnvelopesIntersect
  • ST_IntersectsInterior

Szyfrowanie indeksów

Jeśli używana jest składnica metadanych Parquet, metadane mogą być opcjonalnie szyfrowane przy użyciu szyfrowania Parquet Modular Encryption (PME). Jest to możliwe dzięki zapisywaniu metadanych jako zestawu danych Parquet, dzięki czemu PME może być używane do jego szyfrowania. Ta funkcja ma zastosowanie do wszystkich formatów wejściowych, na przykład zestaw danych zapisany w formacie CSV może mieć swoje metadane zaszyfrowane przy użyciu PME.

W poniższej sekcji, o ile nie określono inaczej, przy odwoływaniu się do stopek, kolumn itd. dotyczą one obiektów metadanych, a nie obiektów w indeksowanym zestawie danych.

Szyfrowanie indeksu jest modułowe i szczegółowe w następujący sposób:

  • Każdy indeks może być zaszyfrowany (z granulacją klucza indeksu) lub pozostawiony w postaci zwykłego tekstu.
  • Stopka + kolumna nazwy obiektu:
    • Kolumna stopki obiektu metadanych, który sam w sobie jest plikiem Parquet, zawiera między innymi:
      • Schemat obiektu metadanych, który ujawnia typy, parametry i nazwy kolumn dla wszystkich zgromadzonych indeksów. Można na przykład dowiedzieć się, że BloomFilter jest zdefiniowany w kolumnie city z fałszywie pozytywnym prawdopodobieństwem 0.1.
      • Pełna ścieżka do oryginalnego zestawu danych lub nazwy tabeli w przypadku tabeli składnicy metadanych Hive .
    • Kolumna nazwy obiektu przechowuje nazwy wszystkich poindeksowanych obiektów.
  • Stopka + kolumna metadanych może mieć jedną z następujących wartości:
    • Oba zaszyfrowane przy użyciu tego samego klucza. Jest to ustawienie domyślne. W tym przypadku konfiguracja stopki zwykłego tekstu dla obiektów Parquet składających się z metadanych w trybie zaszyfrowanej stopki, a kolumna nazwy obiektu jest szyfrowana przy użyciu wybranego klucza.

    • Oba w postaci zwykłego tekstu. W tym przypadku obiekty Parquet składające się na metadane są w trybie stopki zwykłego tekstu, a kolumna nazwy obiektu nie jest szyfrowana.

      Jeśli co najmniej jeden indeks jest oznaczony jako zaszyfrowany, klucz stopki musi być skonfigurowany niezależnie od tego, czy tryb stopki zwykłego tekstu jest włączony, czy nie. Jeśli stopka zwykłego tekstu jest ustawiona, to klawisz stopki jest używany tylko do zabezpieczania przed manipulowaniem. Należy zauważyć, że w takim przypadku kolumna nazwy obiektu nie jest zabezpieczona przed nieuprawnioną manipulacją.

      Jeśli skonfigurowano klucz stopki, co najmniej jeden indeks musi być zaszyfrowany.

Przed użyciem szyfrowania indeksu należy zapoznać się z dokumentacją PME i zapoznać się z tymi pojęciami.

Ważne: Jeśli używane jest szyfrowanie indeksu, za każdym razem, gdy klucz ` key ` jest konfigurowany w dowolnym interfejsie API Xskipper, zawsze jest to etykieta ` NEVER the key alone `.

Aby użyć szyfrowania indeksu:

  1. Wykonaj wszystkie kroki, aby upewnić się, że PME jest włączone. Patrz PME.

  2. Wykonaj wszystkie zwykłe konfiguracje PME, w tym konfiguracje zarządzania kluczami.

  3. Utwórz zaszyfrowane metadane dla zestawu danych:

    1. Aby utworzyć metadane, postępuj zgodnie ze zwykłym przepływem.
    2. Skonfiguruj klucz stopki. Aby ustawić stopkę zwykłego tekstu + kolumnę nazwy obiektu, należy ustawić parametr io.xskipper.parquet.encryption.plaintext.footer na wartość true (patrz przykłady poniżej).
    3. W programie IndexBuilderdla każdego indeksu, który ma być szyfrowany, dodaj etykietę klucza, który ma być używany dla tego indeksu.

    Aby użyć metadanych w czasie wykonywania zapytania lub aby odświeżyć istniejące metadane, nie jest wymagana żadna konfiguracja inna niż zwykła konfiguracja PME wymagana do zapewnienia dostępności kluczy (dosłownie ta sama konfiguracja, która jest potrzebna do odczytania zaszyfrowanego zestawu danych).

Przykłady

W poniższych przykładach przedstawiono tworzenie metadanych przy użyciu klucza o nazwie k1 jako stopki + klucza nazwy obiektu oraz klucza o nazwie k2 jako klucza do szyfrowania MinMax dla temp, a także tworzenie ValueList dla city, który jest pozostawiany w postaci zwykłego tekstu. Należy zauważyć, że w aplikacjach IBM Analytics Engine opartych na technologii Apache Spark, a nie na platformie Watson Studio, można używać tylko platformy Scala.

  • Dla Scala:

    // index the dataset
    val xskipper = new Xskipper(spark, dataset_path)
    // Configuring the JVM wide parameters
    val jvmComf = Map(
      "io.xskipper.parquet.mdlocation" -> md_base_location,
      "io.xskipper.parquet.mdlocation.type" -> "EXPLICIT_BASE_PATH_LOCATION")
    Xskipper.setConf(jvmConf)
    // set the footer key
    val conf = Map(
      "io.xskipper.parquet.encryption.footer.key" -> "k1")
    xskipper.setConf(conf)
    xskipper
      .indexBuilder()
      // Add an encrypted MinMax index for temp
      .addMinMaxIndex("temp", "k2")
      // Add a plaintext ValueList index for city
      .addValueListIndex("city")
      .build(reader).show(false)
    
  • Dla Python

    xskipper = Xskipper(spark, dataset_path)
    # Add JVM Wide configuration
    jvmConf = dict([
      ("io.xskipper.parquet.mdlocation", md_base_location),
      ("io.xskipper.parquet.mdlocation.type", "EXPLICIT_BASE_PATH_LOCATION")])
    Xskipper.setConf(spark, jvmConf)
    # configure footer key
    conf = dict([("io.xskipper.parquet.encryption.footer.key", "k1")])
    xskipper.setConf(conf)
    # adding the indexes
    xskipper.indexBuilder() \
            .addMinMaxIndex("temp", "k1") \
            .addValueListIndex("city") \
            .build(reader) \
            .show(10, False)
    

Jeśli stopka + nazwa obiektu ma pozostać w trybie zwykłego tekstu (jak wspomniano powyżej), należy dodać parametr konfiguracyjny:

  • Dla Scala:

    // index the dataset
    val xskipper = new Xskipper(spark, dataset_path)
    // Configuring the JVM wide parameters
    val jvmComf = Map(
      "io.xskipper.parquet.mdlocation" -> md_base_location,
      "io.xskipper.parquet.mdlocation.type" -> "EXPLICIT_BASE_PATH_LOCATION")
    Xskipper.setConf(jvmConf)
    // set the footer key
    val conf = Map(
      "io.xskipper.parquet.encryption.footer.key" -> "k1",
      "io.xskipper.parquet.encryption.plaintext.footer" -> "true")
    xskipper.setConf(conf)
    xskipper
      .indexBuilder()
      // Add an encrypted MinMax index for temp
      .addMinMaxIndex("temp", "k2")
      // Add a plaintext ValueList index for city
      .addValueListIndex("city")
      .build(reader).show(false)
    
  • Dla Python

    xskipper = Xskipper(spark, dataset_path)
    # Add JVM Wide configuration
    jvmConf = dict([
    ("io.xskipper.parquet.mdlocation", md_base_location),
    ("io.xskipper.parquet.mdlocation.type", "EXPLICIT_BASE_PATH_LOCATION")])
    Xskipper.setConf(spark, jvmConf)
    # configure footer key
    conf = dict([("io.xskipper.parquet.encryption.footer.key", "k1"),
    ("io.xskipper.parquet.encryption.plaintext.footer", "true")])
    xskipper.setConf(conf)
    # adding the indexes
    xskipper.indexBuilder() \
            .addMinMaxIndex("temp", "k1") \
            .addValueListIndex("city") \
            .build(reader) \
            .show(10, False)
    

Pomijanie danych z łączeniami (tylko dla Spark 3)

W środowisku Spark 3 można używać pomijania danych w zapytaniach łączenia, takich jak:

SELECT *
FROM orders, lineitem 
WHERE l_orderkey = o_orderkey and o_custkey = 800

W tym przykładzie przedstawiono schemat gwiaździsty oparty na schemacie testu porównawczego TPC-H (patrz TPC-H), w którym pozycja wiersza jest tabelą faktów i zawiera wiele rekordów, podczas gdy tabela zamówień jest tabelą wymiarów, która zawiera stosunkowo niewielką liczbę rekordów w porównaniu z tabelami faktów.

Powyższe zapytanie zawiera predykat w tabelach zamówień, który zawiera niewielką liczbę rekordów, co oznacza, że użycie wartości min/max nie przyniesie dużej korzyści z pomijania danych.

Dynamiczne pomijanie danych to funkcja, która umożliwia korzystanie z pominięć danych w zapytaniach, takich jak powyższe, przez wyodrębnienie najpierw odpowiednich wartości l_orderkey w oparciu o warunek w tabeli orders , a następnie użycie ich do przekazania predykatu w systemie l_orderkey , który wykorzystuje indeksy pomijania danych do filtrowania nieistotnych obiektów.

Aby użyć tej funkcji, należy włączyć następującą regułę optymalizacji. Należy zauważyć, że w aplikacjach IBM Analytics Engine opartych na technologii Apache Spark, a nie na platformie Watson Studio, można używać tylko platformy Scala.

  • Dla Scala:

      import com.ibm.spark.implicits.
    
      spark.enableDynamicDataSkipping()
    
  • W przypadku Python:

        from sparkextensions import SparkExtensions
    
        SparkExtensions.enableDynamicDataSkipping(spark)
    

Następnie użyj interfejsu API Xskipper jak zwykle, a zapytania będą korzystać z pomijania danych.

Na przykład w powyższym zapytaniu indeksowanie l_orderkey przy użyciu wartości min/max spowoduje pominięcie tabeli lineitem i zwiększenie wydajności zapytania.

Obsługa starszych metadanych

Program Xskipper bezproblemowo obsługuje starsze metadane utworzone przez program MetaIndexManager. Starsze metadane mogą być używane do pomijania, ponieważ aktualizacje metadanych programu Xskipper są wykonywane automatycznie przez następną operację odświeżania.

Jeśli przed indeksem wyświetlana jest wartość DEPRECATED_SUPPORTED podczas wyświetlania listy indeksów lub uruchamiania operacji describeIndex , wersja metadanych jest nieaktualna, ale nadal jest obsługiwana i pomijanie będzie działać. Następna operacja odświeżania spowoduje automatyczne zaktualizowanie metadanych.

Generative AI search and answer
These answers are generated by a large language model in watsonx.ai based on content from the product documentation. Learn more