DataFrame-ek gyorsítótárazása serverless számítási környezetben

Important

Ez a funkció nyilvános előzetes verzióban van. A munkaterület adminisztrátorai az Előzetesek oldalon szabályozhatják a DataFrame-gyorsítótárazás elérését serverless számításon. Lásd: Az Azure Databricks előzetes verziójának kezelése.

Szerver nélküli számítási környezetben egy DataFrame-et gyorsítótárba helyezhet a df.cache() vagy df.persist() használatával, hogy egy költséges eredményt újra felhasználhasson a munkamenetben. Az Azure Databricks kiszámítja a DataFrame-t, amikor meghívod a(z) cache() elemet, és az eredményt pillanatképként materializálja. A DataFrame és az abból összeállított DataFrame-ek akkor a snapshotot olvassák a munkamenet hátralévő részében, ahelyett, hogy újraszámítanák.

Requirements

  • A DataFrame gyorsítótárazása kiszolgáló nélküli számítás esetén előnézete engedélyezve van a munkaterületedben (alapértelmezés szerint engedélyezve). A munkaterület adminei letilthatják azt a Előnézetek oldalon. Az előnézet nem érhető el olyan munkaterületeken, ahol a megfelelőségi biztonsági profil engedélyezve van. Lásd: Munkaterületszintű előzetes verziók kezelése.
  • A kiszolgáló nélküli számítási környezetben futó jegyzetfüzeteknek és feladatoknak 5-ös vagy újabb környezeti verziót kell használniuk.
  • A Databricks Connect-nek Python számára 18.1.8 vagy annál magasabbnak kell lennie, míg a Scala Databricks Connect-nek 18.1.5 vagy annál magasabbnak kell lennie.

A régebbi kliensek kapják a CACHE_REQUIRES_NEWER_CLIENT_ON_SERVERLESS_GC hibát.

Mikor kell használni a DataFrame gyorsítótározást szerver nélküli számításon

Tárolj gyorsítótárban egy DataFrame-et szerver nélküli számítási környezetben, amikor szükséges:

  • Többször is használd újra egy költséges join, aggregálás vagy szűrés eredményét ugyanabban a munkamenetben.
  • Számolj egy streaming mikro-batch-et egyszer egy foreachBatch függvényben, majd írd ki több sinkbe.
  • Tanítsunk vagy hangoljunk több gépi tanulási modellt ugyanazon a felkészített jellemzőadatokon.
  • Őrizzen meg egy stabil állapotképet, miközben több elemzési lépést futtat, még akkor is, ha a forrástáblák változnak.

Lásd Legjobb gyakorlatok.

DataFrame API-k gyorsítótárazása szerver nélküli számítási környezetben

A következő példa egy napi rendeléseket gyorsítótároz, amely az ügyféladatokkal összekapcsolt, kiszámítja a napi teljes bevételt, a bevételt régiónként egy jelentéstáblához csatolja, majd felszabadítja a gyorsítótárt. Mindkét eredmény a gyorsítótárazott pillanatképet olvassa ahelyett, hogy újra futtatná az összekapcsolást.

Python

from pyspark.sql import functions as F

# The DataFrame to cache: one day of orders joined with customer data.
oct_15_orders = (
    spark.table("main.sales.orders")
    .filter(F.col("order_date") == "2026-10-15")
    .join(spark.table("main.sales.customers"), "customer_id")
)
oct_15_orders.cache()

# Both results are built from oct_15_orders, so they read the cached snapshot.
total_revenue = oct_15_orders.agg(F.sum("amount")).first()[0]
print(f"Total revenue on 2026-10-15: {total_revenue}")

revenue_by_region = oct_15_orders.groupBy("order_date", "region").agg(F.sum("amount").alias("revenue"))
revenue_by_region.write.mode("append").saveAsTable("main.reports.revenue_by_region")

# Release the cache and the DataFrame when you no longer need it.
# oct_15_orders and DataFrames built from it can no longer be used.
oct_15_orders.unpersist()

Scala

import org.apache.spark.sql.functions._

// The DataFrame to cache: one day of orders joined with customer data.
val oct15Orders = spark.table("main.sales.orders")
  .filter(col("order_date") === "2026-10-15")
  .join(spark.table("main.sales.customers"), "customer_id")
oct15Orders.cache()

// Both results are built from oct15Orders, so they read the cached snapshot.
val totalRevenue = oct15Orders.agg(sum("amount")).first().get(0)
println(s"Total revenue on 2026-10-15: $totalRevenue")

val revenueByRegion = oct15Orders.groupBy("order_date", "region").agg(sum("amount").alias("revenue"))
revenueByRegion.write.mode("append").saveAsTable("main.reports.revenue_by_region")

// Release the cache and the DataFrame when you no longer need it.
// oct15Orders and DataFrames built from it can no longer be used.
oct15Orders.unpersist()

Az alábbi API-leírásokban a df a munkamenetben lévő bármely DataFrame-re utal, például az előző példában szereplő oct_15_orders-re.

df.cache()

Azonnal számolja df , és gyorsítótárban tárolja az eredményt pillanatképként a munkamenet hátralévő részére.

  • Visszatérési érték: Ugyanaz a gyorsítótárazott DataFrame, df, most már a pillanatkép alapján, nem pedig a forrástáblákon végzett számítás alapján. Lásd az alábbi működést.
  • Viselkedés:
    • Azonnal elindítja a DataFrame lekérdezését, és az eredményt pillanatképként materializálja, mielőtt a hívás visszatérne.
    • A hívás után a df és a visszaadott DataFrame (df maga) a snapshoton alapul. Már nem kapcsolódnak a forrástáblákon végzett számításokhoz, ezért a lekérdezés újraszámítása helyett a pillanatképet olvassák.
    • A közvetlenül a df-ból vagy más, abból származtatott DataFrame-ekből származó DataFrame-ek automatikusan a pillanatképet olvassák be ahelyett, hogy újra lefuttatnák az eredeti lekérdezést. Lásd: Olvasd el a snapshotot.
    • A pillanatkép a saját munkamenetedhez kapcsolódik. Csak az a munkamenet tudja olvasni, amely gyorsítótárba helyezte a(z) df elemet. Lásd : Izoláció és kiváltságok.
    • A pillanatkép a munkamenet végéig tart, legfeljebb hét napig. Ezután az Azure Databricks automatikusan visszafoglalja a tárterületét a háttérben. A(z) df.unpersist() meghívása lehetővé teszi, hogy korábban visszaszerezze a tárhelyet. Lásd: Életciklus és időkorlátok, valamint Tárolás és tisztítás.
    • Ha a df kiszámítása meghibásodik, df.cache() hibát jelez, és df nem kerül gyorsítótárba.
    • Ha a df.cache() műveletet egy már gyorsítótárazott DataFrame-en hívja meg, nem csinál semmit. df nem számolják újra.

A snapshot akkor áll helyre, miután meghívod a df.cache() elemet. A később a táblákba írt adatok, amelyekből df olvas, valamint az említett táblák sémaváltozásai, például a hozzáadott vagy átnevezett oszlopok, nem befolyásolják ezt. A legfrissebb adatokból való újraszámításhoz építsd újra a DataFrame-et a forrástáblákból, és szükség esetén cache-eld az új Dataframe-et.

Olvassa el a pillanatképet

A szerver nélküli számításoknál a cache matching a DataFrame levezetésén alapul. Miután df.cache(), csak a következő DataFrame-ek olvassák be automatikusan a pillanatképet, ahelyett, hogy újraszámolnák a lekérdezést a forrástáblákon:

  • Az Ön által gyorsítótárazott DataFrame, df.
  • A groupBy()-ból származó DataFrame-ek, például select(), filter(), df vagy join().
  • Az ezekből a származtatott DataFrame-ekből tovább láncolt DataFrame-ek.

Egy új DataFrame, amely ugyanazt a lekérdezést ismétli, beolvassa a forrástáblákat, még akkor is, ha a logikája azonos, mert nem származik df.

Ez egyértelművé teszi a gyorsítótár-egyeztetést, és azt a te irányításod alá helyezi: egy DataFrame csak akkor olvassa be a gyorsítótárazott adatokat, ha egy gyorsítótárazott DataFrame-ből származtatod. Minden más DataFrame olvassa a forrástáblákat.

Python

oct_15_orders = (
    spark.table("main.sales.orders")
    .filter(F.col("order_date") == "2026-10-15")
    .join(spark.table("main.sales.customers"), "customer_id")
)
# The join runs one time, when you call cache().
oct_15_orders.cache()

# Derived from oct_15_orders: read the snapshot, so the join doesn't run again.
large_orders = oct_15_orders.filter(F.col("amount") > 1000)
revenue_by_region = oct_15_orders.groupBy("order_date", "region").agg(F.sum("amount").alias("revenue"))

# Derived from large_orders, which is derived from oct_15_orders: also reads the snapshot.
large_orders_by_region = large_orders.groupBy("region").count()

# Not derived from oct_15_orders: reads the source tables and runs the join again.
same_query = (
    spark.table("main.sales.orders")
    .filter(F.col("order_date") == "2026-10-15")
    .join(spark.table("main.sales.customers"), "customer_id")
)

Scala

val oct15Orders = spark.table("main.sales.orders")
  .filter(col("order_date") === "2026-10-15")
  .join(spark.table("main.sales.customers"), "customer_id")
// The join runs one time, when you call cache().
oct15Orders.cache()

// Derived from oct15Orders: read the snapshot, so the join doesn't run again.
val largeOrders = oct15Orders.filter(col("amount") > 1000)
val revenueByRegion = oct15Orders.groupBy("order_date", "region").agg(sum("amount").alias("revenue"))

// Derived from largeOrders, which is derived from oct15Orders: also reads the snapshot.
val largeOrdersByRegion = largeOrders.groupBy("region").count()

// Not derived from oct15Orders: reads the source tables and runs the join again.
val sameQuery = spark.table("main.sales.orders")
  .filter(col("order_date") === "2026-10-15")
  .join(spark.table("main.sales.customers"), "customer_id")

Mivel df a snapshotot olvassa az alapjául szolgáló DataFrame-ek helyett, nem lehet df oszlopaira ezeken a DataFrame-eken keresztül hivatkozni. Lásd Korlátozások.

df.persist(storageLevel)

A(z) df.cache() olyan álneve, amely tárolási szintet fogad el.

  • Paraméterek:
    • storageLevel (nem kötelező): A StorageLevel, például StorageLevel.DISK_ONLY. A kiszolgáló nélküli számítási szolgáltatás bármilyen tárhelyszintet elfogad, és figyelmen kívül hagyja azt. A snapshot minden tárolószintnél ugyanúgy tárolódik, és a(z) df.storageLevel a(z) StorageLevel.DISK_ONLY értéket adja vissza.

A visszatérési érték és viselkedés ugyanaz, mint df.cache().

df.unpersist(blocking)

Feladja a gyorsítótárazott pillanatképet df és megsemmisíti a DataFrame-et.

  • Paraméterek:
    • blocking (opcionális): Figyelmen kívül hagyandó. df.unpersist() mindkét értéknél azonnal visszatér.
  • Visszatérési érték: Ugyanaz a DataFrame, df, amely most megsemmisült.
  • Viselkedés:
    • A pillanatképet úgy jelöli, hogy készen áll a felszabadításra. Az Azure Databricks ezután törli a gyorsítótárban tárolt adatokat, és a háttérben visszafoglalja a tárhelyet.
    • Megsemmisíti a(z) df-t: df, és az ebből korábban származtatott DataFrame-ek többé nem használhatók, valamint a rajtuk végrehajtott minden későbbi lekérdezés CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE kivételt eredményez. Ha gyorsítótárba helyezel egy DataFrame-t, amely a df-ból származik, mielőtt meghívnád a df.unpersist()-t, az a DataFrame használható marad, mert saját pillanatképet kap.
    • Ahhoz, hogy ugyanazzal az adatforrással dolgozzunk, építsünk egy új DataFrame-et az eredeti adatforrásból, ahelyett, hogy újrahasznosítanánk a gyorsítótár nélküli DataFrame-et.
    • A df.unpersist() meghívása egy olyan DataFrame-en, amelyet soha nem gyorsítótáraztak, vagy amelyet már eltávolítottak a gyorsítótárból, nem jár semmilyen művelettel.

Hívd meg a(z) df.unpersist() elemet, amikor már nincs szükséged a gyorsítótárazott adatokra, például amikor a jegyzetfüzet vagy a feladat egy későbbi lépése már nem olvassa azokat. Ez lehetővé teszi, hogy az Azure Databricks korábban visszaszerezze a tárhelyet. Ne használd a(z) df.unpersist() elemet az adatok frissítéséhez. A legfrissebb adatokhoz építs egy új DataFrame-t a forrástáblákból.

Python

oct_15_orders = spark.table("main.sales.orders").filter(F.col("order_date") == "2026-10-15")
oct_15_orders.cache()
large_orders = oct_15_orders.filter(F.col("amount") > 1000)
orders_per_customer = oct_15_orders.groupBy("customer_id").count()
orders_per_customer.cache()  # Has its own snapshot.

# Acknowledge that the cached data is no longer needed.
# This releases the storage and destroys oct_15_orders.
oct_15_orders.unpersist()

oct_15_orders.count()  # Raises CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
large_orders.count()  # Raises CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
orders_per_customer.count()  # Reads its own snapshot.

# If you need the data again later, build a new DataFrame from the source tables.
oct_15_orders = spark.table("main.sales.orders").filter(F.col("order_date") == "2026-10-15")

Scala

var oct15Orders = spark.table("main.sales.orders").filter(col("order_date") === "2026-10-15")
oct15Orders.cache()
val largeOrders = oct15Orders.filter(col("amount") > 1000)
val ordersPerCustomer = oct15Orders.groupBy("customer_id").count()
ordersPerCustomer.cache() // Has its own snapshot.

// Acknowledge that the cached data is no longer needed.
// This releases the storage and destroys oct15Orders.
oct15Orders.unpersist()

oct15Orders.count() // Throws CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
largeOrders.count() // Throws CACHE_DATAFRAME_ACCESS_AFTER_UNCACHE.
ordersPerCustomer.count() // Reads its own snapshot.

// If you need the data again later, build a new DataFrame from the source tables.
oct15Orders = spark.table("main.sales.orders").filter(col("order_date") === "2026-10-15")

df.storageLevel

Lekéri a tárolási szintet df.

  • Visszatérési érték: StorageLevel.DISK_ONLY ad vissza, miközben df gyorsítótárban van. StorageLevel.NONE mielőtt gyorsítótárba helyezed, és miután meghívtad a(z) df.unpersist()-t.

Python

from pyspark import StorageLevel

oct_15_orders.cache()
oct_15_orders.storageLevel == StorageLevel.DISK_ONLY  # True

Scala

import org.apache.spark.storage.StorageLevel

oct15Orders.cache()
oct15Orders.storageLevel == StorageLevel.DISK_ONLY // true

A metódusaláírásokat illetően lásd a PySpark referenciáját a cache, persist, unpersist és storageLevel esetében.

Életciklus és időkorlátok

A gyorsítótárazott adatok csak abban az Azure Databricks-munkamenetben léteznek, amelyben gyorsítótárban tárolod őket. Elérhetetlenné válik, amikor a munkamenet véget ér, és legfeljebb hét napig tart. A hétnapos korlát után egy gyorsítótárazott DataFrame használata hibát jelez, ahelyett, hogy újra olvasnánk a forrástáblákat. Az újbóli gyorsítótárazáshoz indíts új munkamenetet.

Tárolás és tisztítás

Az Azure Databricks automatikusan kezeli a gyorsítótárazott adatok tárolását. A gyorsítótározott adatok felhőalapú tárolásban vannak, a konkrét tárolóhely pedig a munkaterület típusától függ:

  • Szerver nélküli munkaterületek: A gyorsítótárazott adatok alapértelmezett tárolóban vannak tárolva. Ha beállítottál egy ügyfél által kezelt kulcsot menedzselt szolgáltatásokhoz, akkor a gyorsítótárazott adatok ezt a kulcsot használják. A titkosításhoz az ügyfél által kezelt kulcsokat lásd .

Miután a gyorsítótárazott adatok elérhetetlenné válnak, az Azure Databricks automatikusan visszafoglalja a tárhelyet a háttérben. Ez magában foglalja azokat az eseteket is, amikor a munkamenet megszakítás vagy összeomlás miatt véget ér. A(z) df.unpersist() meghívása lehetővé teszi az Azure Databricks számára, hogy korábban visszaszerezze a tárolóterületet.

Elkülönítés és jogosultságok

Bármely felhasználó, aki serverless számítási környezetben tud kódot futtatni, gyorsítótárazhat egy DataFrame-et. Nincs szükséged plusz kiváltságokra.

A gyorsítótárazott adatok munkamenet-szintű izolációt biztosítanak. Csak az a munkamenet tudja olvasni a gyorsítótárazott adatokat, amely gyorsítótárba helyezte a DataFrame-et. Más felhasználók nem férhetnek hozzá, beleértve az ugyanazon jegyzetfüzet többi felhasználóját is.

A gyorsítótárban tárolt adatok azt tartalmazták, amit olvashattál, amikor gyorsítótárba mentetted. A forrástáblákra alkalmazott engedélymódosítások, sorszűrők és oszlopmaszkok nem vonatkoznak a gyorsítótározott adatokra.

Bevált gyakorlatok

  • Gyorsítótárazz, amikor stabil snapshotra van szükséged: Ha több transzformációt, aggregációt vagy lefúrást végzel ugyanazon a kiszámított adathalmazon, a snapshot egy következetes alapvonalat ad, amely nem változik, amikor a forrástáblák változnak.
  • Tárazza gyorsítótárba a költséges számításokat, ne az egyszerű táblaolvasásokat: df.cache() materializálja a lekérdezés eredményét, majd később az olvasások ezt a pillanatképet pásztázzák. Ha sima táblaolvasást gyorsítótárba helyezel, például spark.table("main.sales.orders").cache(), a későbbi olvasások még mindig a teljes tábla egy teljes másolatát vizsgálják át, így a gyorsítótárazás kevés megtakarítást eredményez. A gyorsítótárazás megtérül az erőforrás-igényes műveletek, például összevonások, aggregációk és összetett szűrők után.
  • Ne gyorsítótárazz olyan adatokat, amelyeket csak egyszer olvastál: df.cache() az eredményt azonnal kiszámítja és tárolja, ami időt és tárhelyet igényel. Ha csak egyszer olvasod el az eredményt, a kezdeti költség nem éri meg.
  • Használja a gyorsítótárat a gyorsítótárazott DataFrame-ből kiindulva: A pillanatkép olvasásához a későbbi műveleteket a gyorsítótárazott DataFrame változóra építse, például df.select(...) vagy df.filter(...). Egy független DataFrame, amely ugyanabból a számításból épül fel a forrástáblákon, nem használja a gyorsítótárt.
  • Ne használd a cache-t a munkamenetek közötti vagy a felhasználók közötti adatmegosztáshoz: A gyorsítótárazott adatok a munkamenetedhez tartoznak és privátak. Más munkamenetek, jegyzetfüzetek, feladatfuttatások és felhasználók nem tudják elolvasni. A kiszámított eredmények megosztásához a munkamenetek között vagy más felhasználókkal, írd ki őket egy állandó táblába.
  • Tartsd a gyorsítótárazott adatokkal rendelkező üléseket hét napnál rövidebb ideig: Lásd: Életciklus és időkorlátok. Ha a munkafolyamatodnak hosszabb ideig szüksége van az adatokra, írd egy táblába.
  • Hívd df.unpersist() meg, amikor már nincs szükség a gyorsítótárra rakott adatokra: Ez lehetővé teszi az Azure Databricks számára, hogy korábban felszabadítsa a tárhelyet. A hívás után a DataFrame és az abból származtatott DataFrame-ek nem használhatók.
  • Ne használd df.unpersist() az adatok frissítésére: df.unpersist() véget vet a pillanatkép életének. A forrástáblák változásainak átvételéhez építs egy új DataFrame-t a forrástáblákból.

Limitations

A DataFrame gyorsítótárazásnak a szerver nélküli számításban a következő korlátai vannak:

  • Oszlopnevek és típusok: Az alábbi DataFrame-ek nem gyorsítótárazhatók. Nevezd át vagy castold az oszlopokat, mielőtt gyorsítótárazod, például .alias("total_amount").
    • DataFrame-ek duplikált oszlopnevekkel.
    • Adatkeretek, amelyek oszlopnevei szóközt vagy a ,;{}()= karakterek bármelyikét tartalmazzák, például az aggregációból származó sum(amount).
    • DataFrame-ek intervallum oszlopokkal.
    • Adatkeretek, amelyek NULL típusú értékeket tartalmazó tömböket, leképezéseket vagy szerkezeteket tartalmaznak.
    • Adatkeretek, amelyeknek nincs oszlopa, vagy csak NULL típusú oszlopokat tartalmaznak.
  • Oszlophivatkozások: Miután gyorsítótáraztad a DataFrame-et, nem hivatkozhatsz az oszlopaira azokon a DataFrame-eken keresztül, amelyekből épült. Például oct_15_orders.cache() és oct_15_orders = orders.join(customers, "customer_id") után oct_15_orders.select(orders.amount) megemeli CANNOT_RESOLVE_DATAFRAME_COLUMN. Használja inkább a oct_15_orders.amount vagy "amount" elemet.
  • SQL és katalóguscache API-k: SQL cache utasítások, mint például CACHE TABLE, és a spark.catalog táblacache-metódusai nem támogatottak serverless compute-on. Lásd a gyorsítótárazás korlátai. Az SQL lekérdezési eredményének újrafelhasználásához használjunk egy session-local ideiglenes táblát.
  • Információs séma lekérdezések: Amikor sok munkamenet DataFrame-eket táraz a metastore gyorsítótárában, a information_schema.volumes és information_schema.schemata lekérdezései lassúak lehetnek, vagy időtúllépést okozhatnak. A volumes katalógus szerinti szűrése nem gyorsítja fel a lekérdezést. A(z) information_schema.tables lekérdezéseket ez nem érinti.
  • Azure Government regions: A DataFrame-gyorstárazás nem támogatott a kiszolgáló nélküli számítási környezetben az Azure Government-régiókban.
  • Figyelmen kívül hagyott paraméterek: df.persist(storageLevel) figyelmen kívül hagyja a tárolási szintet, és df.unpersist(blocking) figyelmen blockingkívül hagyja . Lásd: df.persist(storageLevel) és df.unpersist(blocking).

Migrálás a klasszikus számítási környezetből

A legtöbb munkaterhelésnél a gyorsítótárazás serverless számítási környezetben ugyanazt az eredményt adja, mint a klasszikus számítási környezetben, és a meglévő kód változtatás nélkül fut. Az alábbi táblázat felsorolja a különbségeket.

Behavior Kiszolgáló nélküli számítás Klasszikus számítás
Gyorsítótár-egyeztetés Csak a gyorsítótárazott DataFrame és az abból származtatott DataFrame-ek használják automatikusan a gyorsítótárt. Bármely lekérdezés, amelynek ugyanaz a lekérdezési terv alakja van, automatikusan használja a gyorstárat.
Adatok frissessége A(z) df.cache() meghívásakor készített konzisztens pillanatkép. Változó: bizonyos esetekben gyorsítótárban tárolt adatokat frissítenek, máskor pedig pillanatképet szolgáltatnak.
Megosztás hatóköre Privát a saját munkamenetedhez. Megosztva a klaszteren belüli munkamenetek között.
Anyagosítás Eager: azonnal kiszámításra kerül, amikor hívod df.cache(). Lazy: az első műveletkor kerül kiszámításra a DataFrame-en.
df.unpersist() Megsemmisíti a DataFrame-et, és determinisztikusan felszabadítja annak pillanatképét. Felszabadítja a memóriabeli gyorsítótárat. A DataFrame későbbi használata a terméktől és az adatforrástól függően a legfrissebb vagy elavult adatokat is adhatja vissza.

Az alábbiak részletesebben ismertetik az első két különbséget:

  • Cache egyeztetés:
    • A változás által érintett munkaterhelések: A legtöbb munkaterhelés nem érintett. Ha továbbra is használod a gyorsítótárazott DataFrame-változót, például a(z) df.select(...) vagy df.filter(...) használatával, a gyorsítótár úgy működik, mint korábban. A változás csak azokat a munkaterheléseket érinti, ahol egy függetlenül felépített DataFrame vagy SQL lekérdezés újrahasználja a gyorsítótárt, mert azonos végrehajtási tervstruktúrával rendelkezik. Szerver nélküli számítás esetén ezek a lekérdezések a forrástáblákat olvassák.
    • Ha a számítási feladat érintett: Használd a gyorsítótárazott DataFrame-változót ott, ahol szükség van a gyorsítótárazott eredményre, ahelyett, hogy ugyanazt a lekérdezést építenéd újra.
  • Adatfrissítés:
    • A változás által érintett munkaterhelések: A legtöbb munkaterhelés nem érintett, mert a gyorsítótározott adatokat újra olvasni a forrástáblákra való írás után ritka. A változás csak azokat a munkaterheléseket érinti, amelyek a forrástáblákba írnak, majd azt várják, hogy a gyorsítótárazott DataFrame megjelenítse az új adatokat.
    • Ha a munkaterhelés érintett: Miután írtál a forrástáblákra, építs belőlük egy új DataFrame-et a gyorsítótározott helyett.

További erőforrások

  • Utolsó frissítés időpontja: