Datenzugriff in Jupyterlab Notebooks
Jeder unterstützte Kernel bietet native Funktionen, mit denen Sie Platform-Daten aus einem Datensatz in einem Notebook lesen können. Derzeit unterstützt JupyterLab in Adobe Experience Platform Data Science Workspace Notebooks für Python, R, PySpark und Scala. Die Unterstützung für die Paginierung von Daten ist jedoch auf Python und R Notebooks. In diesem Handbuch wird beschrieben, wie Sie mit JupyterLab-Notebooks auf Ihre Daten zugreifen können.
Erste Schritte
Bevor Sie dieses Handbuch lesen, nutzen Sie bitte das JupyterLab Benutzerhandbuch für eine allgemeine Einführung in JupyterLab und dessen Rolle im Datenwissenschafts-Arbeitsbereich.
Einschränkungen für Notebook-Daten notebook-data-limits
Die folgenden Informationen definieren die maximale Datenmenge, die gelesen werden kann, welche Art von Daten verwendet wurde und den geschätzten Zeitrahmen, in dem die Daten gelesen werden.
Für Python und R, ein mit 40 GB RAM konfigurierter Notebook-Server, wurde für die Benchmarks verwendet. Für PySpark und Scala wurde ein mit 64 GB RAM, 8 Kernen und 2 DBU konfigurierter Datenbank-Cluster mit maximal 4 Workern für die unten beschriebenen Benchmarks verwendet.
Die verwendeten ExperienceEvent-Schemadaten variierten in ihrer Größe von 1.000 Zeilen (1.000) bis zu einer Milliarde (1.000) Zeilen. Beachten Sie Folgendes für den PySpark und Spark Metriken wurde für die XDM-Daten ein Datumsbereich von 10 Tagen verwendet.
Die Ad-hoc-Schemadaten wurden mit Query Service Erstellen Sie eine Tabelle als "Select"(CTAS). Diese Daten variierten auch von 100 (1.000) Zeilen bis zu einer Milliarde (1.000) Zeilen.
Verwendung des Batch-Modus im Vergleich zum interaktiven Modus mode
Beim Lesen von Datensätzen mit PySpark- und Scala-Notebooks haben Sie die Möglichkeit, den interaktiven Modus oder Batch-Modus zu verwenden, um den Datensatz zu lesen. Interaktiv erfolgt für schnelle Ergebnisse, während der Batch-Modus für große Datensätze verwendet wird.
Python Datenbeschränkungen für Notebooks
XDM ExperienceEvent-Schema: Sie sollten maximal 2 Millionen Zeilen (~6,1 GB Daten auf der Festplatte) von XDM-Daten in weniger als 22 Minuten lesen können. Das Hinzufügen zusätzlicher Zeilen kann zu Fehlern führen.
Ad-hoc-Schema: Sie sollten maximal 5 Millionen Zeilen (~5,6 GB Daten auf der Festplatte) von Nicht-XDM-Daten (Ad-hoc-Daten) in weniger als 14 Minuten lesen können. Das Hinzufügen zusätzlicher Zeilen kann zu Fehlern führen.
R Notebook-Datenbeschränkungen
XDM ExperienceEvent-Schema: Sie sollten maximal 1 Million Zeilen XDM-Daten (3 GB Daten auf der Festplatte) in weniger als 13 Minuten lesen können.
Ad-hoc-Schema: Sie sollten maximal 3 Millionen Zeilen Ad-hoc-Daten (293 MB Daten auf der Festplatte) in etwa 10 Minuten lesen können.
PySpark (Python Kernel) Notebook-Datenbeschränkungen: pyspark-data-limits
XDM ExperienceEvent-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~13,42 GB Daten auf der Festplatte) von XDM-Daten in etwa 20 Minuten lesen können. Der interaktive Modus unterstützt nur bis zu 5 Millionen Zeilen. Wenn Sie größere Datensätze lesen möchten, wird empfohlen, in den Batch-Modus zu wechseln. Im Batch-Modus sollten Sie in der Lage sein, maximal 500 Millionen Zeilen (~1,31 TB-Daten auf der Festplatte) von XDM-Daten in etwa 14 Stunden zu lesen.
Ad-hoc-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~5,36 GB Daten auf der Festplatte) von Nicht-XDM-Daten in weniger als 3 Minuten lesen können. Im Batch-Modus sollten Sie in der Lage sein, maximal 1 Milliarde Zeilen (~1,05 TB Daten auf der Festplatte) von Nicht-XDM-Daten in etwa 18 Minuten zu lesen.
Spark (Scala-Kernel) Notebook-Datenbeschränkungen: scala-data-limits
XDM ExperienceEvent-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~13,42 GB Daten auf der Festplatte) von XDM-Daten in etwa 18 Minuten lesen können. Der interaktive Modus unterstützt nur bis zu 5 Millionen Zeilen. Wenn Sie größere Datensätze lesen möchten, wird empfohlen, in den Batch-Modus zu wechseln. Im Batch-Modus sollten Sie in der Lage sein, maximal 500 Millionen Zeilen (~1,31 TB-Daten auf der Festplatte) von XDM-Daten in etwa 14 Stunden zu lesen.
Ad-hoc-Schema: Im interaktiven Modus sollten Sie maximal 5 Millionen Zeilen (~5,36 GB Daten auf der Festplatte) von Nicht-XDM-Daten in weniger als 3 Minuten lesen können. Im Batch-Modus sollten Sie in der Lage sein, maximal 1 Milliarde Zeilen (~1,05 TB Daten auf der Festplatte) von Nicht-XDM-Daten in etwa 16 Minuten zu lesen.
Python Notebooks python-notebook
Python Mit Notebooks können Sie Daten beim Zugriff auf Datensätze paginieren. Nachstehend finden Sie Beispiel-Code zum Lesen von Daten mit und ohne Paginierung. Weitere Informationen zu den verfügbaren Start-Python-Notebooks finden Sie im JupyterLab Starter im JupyterLab-Benutzerhandbuch.
In der folgenden Python-Dokumentation werden die folgenden Konzepte beschrieben:
Aus einem Datensatz in Python lesen python-read-dataset
Ohne Paginierung:
Wenn Sie den folgenden Code ausführen, wird der gesamte Datensatz gelesen. Bei erfolgreicher Ausführung werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df
verweist.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.read()
df.head()
Mit Paginierung:
Wenn Sie folgenden Code ausführen, werden Daten aus dem angegebenen Datensatz gelesen. Paginierung wird erreicht, indem Daten über die Funktion limit()
bzw. offset()
begrenzt und versetzt werden. Datenbegrenzung bezieht sich auf die maximale Anzahl der zu lesenden Datenpunkte, während Versatz auf die Anzahl der Datenpunkte verweist, die vor dem Lesen von Daten übersprungen werden. Wenn der Lesevorgang erfolgreich ausgeführt wird, werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df
verweist.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.limit(100).offset(10).read()
Schreiben in einen Datensatz in Python write-python
Um in einen Datensatz in Ihrem JupyterLab-Notebook zu schreiben, wählen Sie im linken Navigationsbereich von JupyterLab die Registerkarte Datensymbol (unten hervorgehoben). Die Verzeichnisse Datensätze und Schemata werden angezeigt. Auswählen Datensätze Klicken Sie mit der rechten Maustaste und wählen Sie dann die Daten in Notebook schreiben im Dropdown-Menü des Datensatzes, den Sie verwenden möchten. Unten im Notebook wird ein ausführbarer Code-Eintrag angezeigt.
- Verwendung Daten in Notebook schreiben , um eine Schreibzelle mit dem ausgewählten Datensatz zu generieren.
- Verwendung Daten in Notebook erkunden , um eine Lesezelle mit dem ausgewählten Datensatz zu generieren.
- Verwendung Abfragedaten in Notebook , um eine einfache Abfragezelle mit Ihrem ausgewählten Datensatz zu generieren.
Alternativ können Sie die folgende Code-Zelle kopieren und einfügen. Ersetzen Sie beide {DATASET_ID}
und {PANDA_DATAFRAME}
.
from platform_sdk.models import Dataset
from platform_sdk.dataset_writer import DatasetWriter
dataset = Dataset(get_platform_sdk_client_context()).get_by_id(dataset_id="{DATASET_ID}")
dataset_writer = DatasetWriter(get_platform_sdk_client_context(), dataset)
write_tracker = dataset_writer.write({PANDA_DATAFRAME}, file_format='json')
Abfragedaten verwenden Query Service in Python query-data-python
JupyterLab on Platform ermöglicht Ihnen die Verwendung von SQL in einer Python Notebook für den Datenzugriff über Adobe Experience Platform Query Service. Der Zugriff auf Daten über den Query Service kann aufgrund der kürzeren Ausführungszeiten bei der Bearbeitung großer Datensätze nützlich sein. Beachten Sie, dass Datenabfragen mit dem Query Service ein Limit bei der Verarbeitungszeit von 10 Minuten aufweisen.
Bevor Sie den Query Service in JupyterLab verwenden, sollten Sie Grundlagenkenntnisse zur Query Service -SQL-Syntax besitzen.
Abfrage von Daten mit Query Service erfordert, dass Sie den Namen des Zieldatensatzes angeben. Sie können die erforderlichen Code-Zellen generieren, indem Sie den gewünschten Datensatz mit dem Data Explorer suchen. Klicken Sie mit der rechten Maustaste auf die Datensatzliste und klicken Sie auf Abfragedaten in Notebook , um zwei Code-Zellen in Ihrem Notebook zu generieren. Diese beiden Zellen werden nachfolgend detaillierter beschrieben.
Um Query Service in JupyterLab, müssen Sie zunächst eine Verbindung zwischen Ihrer Arbeit erstellen Python Notebook und Query Service. Dies kann durch Ausführen der ersten generierten Zelle erreicht werden.
qs_connect()
In der zweiten generierten Zelle muss die erste Zeile vor der SQL-Abfrage definiert werden. Standardmäßig definiert die generierte Zelle eine optionale Variable (df0
), mit der die Abfrageergebnisse als Pandas-Dataframe gespeichert werden.
Die -c QS_CONNECTION
-Argument ist obligatorisch und weist den Kernel an, die SQL-Abfrage für auszuführen Query Service. Eine Liste weiterer Argumente finden Sie im Anhang.
%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/
Python-Variablen können in einer SQL-Abfrage direkt referenziert werden, indem Sie eine im Zeichenfolgenformat formatierte Syntax verwenden und die Variablen in geschweifte Klammern ({}
) setzen (siehe folgendes Beispiel):
table_name = 'name_of_the_dataset'
table_columns = ','.join(['col_1','col_2','col_3'])
%%read_sql demo -c QS_CONNECTION
SELECT {table_columns}
FROM {table_name}
Filter ExperienceEvent data python-filter
Um auf eine ExperienceEvent Datensatz in einem Python Notebook müssen Sie die Kennung des Datensatzes ({DATASET_ID}
) zusammen mit den Filterregeln, die mithilfe logischer Operatoren einen bestimmten Zeitraum definieren. Wenn ein Zeitraum definiert ist, wird jede angegebene Paginierung ignoriert und der gesamte Datensatz berücksichtigt.
Eine Liste der Filteroperatoren finden Sie nachfolgend:
eq()
: Gleichgt()
: Größer alsge()
: Größer oder gleichlt()
: Niedriger alsle()
: Kleiner oder gleichAnd()
: Logischer UND-OperatorOr()
: Logischer ODER-Operator
Die folgende Zelle filtert eine ExperienceEvent Datensatz zu Daten, die ausschließlich zwischen dem 1. Januar 2019 und dem 31. Dezember 2019 existieren.
# Python
from platform_sdk.dataset_reader import DatasetReader
dataset_reader = DatasetReader(get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df = dataset_reader.\
where(dataset_reader["timestamp"].gt("2019-01-01 00:00:00").\
And(dataset_reader["timestamp"].lt("2019-12-31 23:59:59"))\
).read()
R Notebooks r-notebooks
Mit R-Notebooks können Sie Daten beim Zugriff auf Datensätze paginieren. Nachstehend finden Sie Beispiel-Code zum Lesen von Daten mit und ohne Paginierung. Weitere Informationen zu den verfügbaren Start-R-Notebooks finden Sie im JupyterLab Starter im JupyterLab-Benutzerhandbuch.
In der folgenden R-Dokumentation werden die folgenden Konzepte beschrieben:
Aus einem Datensatz in R lesen r-read-dataset
Ohne Paginierung:
Wenn Sie den folgenden Code ausführen, wird der gesamte Datensatz gelesen. Bei erfolgreicher Ausführung werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df0
verweist.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$read()
head(df0)
Mit Paginierung:
Wenn Sie folgenden Code ausführen, werden Daten aus dem angegebenen Datensatz gelesen. Paginierung wird erreicht, indem Daten über die Funktion limit()
bzw. offset()
begrenzt und versetzt werden. Datenbegrenzung bezieht sich auf die maximale Anzahl der zu lesenden Datenpunkte, während Versatz auf die Anzahl der Datenpunkte verweist, die vor dem Lesen von Daten übersprungen werden. Wenn der Lesevorgang erfolgreich ausgeführt wird, werden die Daten als Pandas-Dataframe gespeichert, auf den die Variable df0
verweist.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$limit(100L)$offset(10L)$read()
Schreiben in einen Datensatz in R write-r
Um in einen Datensatz in Ihrem JupyterLab-Notebook zu schreiben, wählen Sie im linken Navigationsbereich von JupyterLab die Registerkarte Datensymbol (unten hervorgehoben). Die Verzeichnisse Datensätze und Schemata werden angezeigt. Auswählen Datensätze Klicken Sie mit der rechten Maustaste und wählen Sie dann die Daten in Notebook schreiben im Dropdown-Menü des Datensatzes, den Sie verwenden möchten. Unten im Notebook wird ein ausführbarer Code-Eintrag angezeigt.
- Verwendung Daten in Notebook schreiben , um eine Schreibzelle mit dem ausgewählten Datensatz zu generieren.
- Verwendung Daten in Notebook erkunden , um eine Lesezelle mit dem ausgewählten Datensatz zu generieren.
Alternativ können Sie die folgende Code-Zelle kopieren und einfügen:
psdk <- import("platform_sdk")
dataset <- psdk$models$Dataset(py$get_platform_sdk_client_context())$get_by_id(dataset_id="{DATASET_ID}")
dataset_writer <- psdk$dataset_writer$DatasetWriter(py$get_platform_sdk_client_context(), dataset)
write_tracker <- dataset_writer$write(df, file_format='json')
Filter ExperienceEvent data r-filter
Um auf eine ExperienceEvent -Datensatz in einem R-Notebook verwenden, müssen Sie die Kennung des Datensatzes ({DATASET_ID}
) zusammen mit den Filterregeln, die mithilfe logischer Operatoren einen bestimmten Zeitraum definieren. Wenn ein Zeitraum definiert ist, wird jede angegebene Paginierung ignoriert und der gesamte Datensatz berücksichtigt.
Eine Liste der Filteroperatoren finden Sie nachfolgend:
eq()
: Gleichgt()
: Größer alsge()
: Größer oder gleichlt()
: Niedriger alsle()
: Kleiner oder gleichAnd()
: Logischer UND-OperatorOr()
: Logischer ODER-Operator
Die folgende Zelle filtert eine ExperienceEvent Datensatz zu Daten, die ausschließlich zwischen dem 1. Januar 2019 und dem 31. Dezember 2019 existieren.
# R
library(reticulate)
use_python("/usr/local/bin/ipython")
psdk <- import("platform_sdk")
datetime <- import("datetime", convert = FALSE)
py_run_file("~/.ipython/profile_default/startup/platform_sdk_context.py")
client_context <- py$PLATFORM_SDK_CLIENT_CONTEXT
DatasetReader <- psdk$dataset_reader$DatasetReader
dataset_reader <- DatasetReader(py$get_platform_sdk_client_context(), dataset_id="{DATASET_ID}")
df0 <- dataset_reader$
where(dataset_reader["timestamp"]$gt("2019-01-01 00:00:00")$
And(dataset_reader["timestamp"]$lt("2019-12-31 23:59:59"))
)$read()
PySpark 3 Notebooks pyspark-notebook
In der folgenden PySpark-Dokumentation werden die folgenden Konzepte beschrieben:
Initialisieren von sparkSession spark-initialize
Alle Spark 2.4 Notebooks erfordern, dass Sie die Sitzung mit dem folgenden Textbausteincode initialisieren.
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
Verwenden von %dataset zum Lesen und Schreiben mit einem PySpark 3-Notebook magic
Mit der Einführung von Spark 2.4. %dataset
Benutzerdefinierte Magie wird für die Verwendung in PySpark 3 bereitgestellt (Spark 2.4) Notebooks. Weitere Informationen zu magischen Befehlen, die im IPython-Kernel verfügbar sind, finden Sie im Dokumentation zur IPython-Magie.
Verwendung
%dataset {action} --datasetId {id} --dataFrame {df} --mode batch
Beschreibung
Benutzerdefiniert Data Science Workspace Zauberbefehl zum Lesen oder Schreiben eines Datensatzes aus einem PySpark Notebook (Python 3 Kernel).
{action}
--datasetId {id}
--dataFrame {df}
Der pandas-Dataframe.
- Wenn die Aktion "read"lautet, ist {df} die Variable, in der Ergebnisse des Datensatzlesevorgangs verfügbar sind (z. B. ein Dataframe).
- Wenn die Aktion "write"lautet, wird dieser Dataframe {df} in den Datensatz geschrieben.
--mode
Es wird empfohlen, den "interaktiven"Modus zu verwenden, um die Abfrageleistung bei kleineren Datensätzen zu verbessern.
mode
auf interactive
oder batch
.Beispiele
- Beispiel lesen:
%dataset read --datasetId 5e68141134492718af974841 --dataFrame pd0 --mode batch
- Beispiel schreiben:
%dataset write --datasetId 5e68141134492718af974842 --dataFrame pd0 --mode batch
df.cache()
vor dem Schreiben von Daten kann die Notebook-Leistung erheblich verbessern. Dies kann hilfreich sein, wenn Sie einen der folgenden Fehler erhalten:- Auftrag aufgrund von Staging-Fehler abgebrochen … Kann nur RDDs mit derselben Anzahl von Elementen in jeder Partition komprimieren.
- Remote RPC-Client getrennt und andere Speicherfehler.
- Schlechte Leistung beim Lesen und Schreiben von Datensätzen.
Sie können die oben genannten Beispiele automatisch im JupyterLab-Buy mit der folgenden Methode generieren:
Wählen Sie im linken Navigationsbereich von JupyterLab die Registerkarte Datensymbol (unten hervorgehoben). Die Verzeichnisse Datensätze und Schemata werden angezeigt. Auswählen Datensätze Klicken Sie mit der rechten Maustaste und wählen Sie dann die Daten in Notebook schreiben im Dropdown-Menü des Datensatzes, den Sie verwenden möchten. Unten im Notebook wird ein ausführbarer Code-Eintrag angezeigt.
- Verwendung Daten in Notebook erkunden , um eine Lese-Zelle zu generieren.
- Verwendung Daten in Notebook schreiben , um eine Schreibzelle zu erstellen.
Lokalen Dataframe erstellen pyspark-create-dataframe
Verwenden Sie SQL-Abfragen, um einen lokalen Dataframe mit PySpark 3 zu erstellen. Beispiel:
date_aggregation.createOrReplaceTempView("temp_df")
df = spark.sql('''
SELECT *
FROM sparkdf
''')
local_df
df = spark.sql('''
SELECT *
FROM sparkdf
LIMIT limit
''')
sample_df = df.sample(fraction)
Filter ExperienceEvent data pyspark-filter-experienceevent
Zugreifen auf und Filtern von ExperienceEvent -Datensatz in einem PySpark-Notebook erfordert, dass Sie die Datensatz-Identität angeben ({DATASET_ID}
), die IMS-Identität Ihres Unternehmens und die Filterregeln, die einen bestimmten Zeitraum definieren. Ein Filterzeitbereich wird mithilfe der Funktion spark.sql()
, wobei der Funktionsparameter eine SQL-Abfragezeichenfolge ist.
Die folgenden Zellen filtern eine ExperienceEvent Datensatz zu Daten, die ausschließlich zwischen dem 1. Januar 2019 und dem 31. Dezember 2019 existieren.
# PySpark 3 (Spark 2.4)
from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()
%dataset read --datasetId {DATASET_ID} --dataFrame df --mode batch
df.createOrReplaceTempView("event")
timepd = spark.sql("""
SELECT *
FROM event
WHERE timestamp > CAST('2019-01-01 00:00:00.0' AS TIMESTAMP)
AND timestamp < CAST('2019-12-31 23:59:59.9' AS TIMESTAMP)
""")
timepd.show()
Scala Notebooks scala-notebook
Die folgende Dokumentation enthält Beispiele für die folgenden Konzepte:
Initialisieren von SparkSession scala-initialize
Bei allen Scala-Notebooks müssen Sie die Sitzung mit dem folgenden Textbausteincode initialisieren:
import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
.builder()
.master("local")
.getOrCreate()
Datensatz lesen read-scala-dataset
In Scala können Sie clientContext
Um Platform-Werte abzurufen und zurückzugeben, entfällt dadurch die Notwendigkeit, Variablen wie var userToken
. Im folgenden Scala-Beispiel: clientContext
wird verwendet, um alle zum Lesen eines Datensatzes erforderlichen Werte abzurufen und zurückzugeben.
df.cache()
vor dem Schreiben von Daten kann die Notebook-Leistung erheblich verbessern. Dies kann hilfreich sein, wenn Sie einen der folgenden Fehler erhalten:- Auftrag aufgrund von Staging-Fehler abgebrochen … Kann nur RDDs mit derselben Anzahl von Elementen in jeder Partition komprimieren.
- Remote RPC-Client getrennt und andere Speicherfehler.
- Schlechte Leistung beim Lesen und Schreiben von Datensätzen.
import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()
val clientContext = ClientContext.getClientContext()
val df1 = spark.read.format("com.adobe.platform.query")
.option("user-token", clientContext.getUserToken())
.option("ims-org", clientContext.getOrgId())
.option("api-key", clientContext.getApiKey())
.option("service-token", clientContext.getServiceToken())
.option("sandbox-name", clientContext.getSandboxName())
.option("mode", "batch")
.option("dataset-id", "5e68141134492718af974844")
.load()
df1.printSchema()
df1.show(10)
clientContext.getUserToken()
.clientContext.getServiceToken()
.clientContext.getOrgId()
.clientContext.getApiKey()
.mode
auf interactive
oder batch
.Sie können das obige Beispiel automatisch im JupyterLab-Buy mit der folgenden Methode generieren:
Wählen Sie im linken Navigationsbereich von JupyterLab die Registerkarte Datensymbol (unten hervorgehoben). Die Verzeichnisse Datensätze und Schemata werden angezeigt. Wählen Sie Datensätze aus, klicken Sie mit der rechten Maustaste und wählen Sie dann im Dropdown-Menü des Datensatzes, den Sie verwenden möchten, die Option Daten in Notebook erkunden aus. Unten im Notebook wird ein ausführbarer Code-Eintrag angezeigt.
Und
- Verwendung Daten in Notebook erkunden , um eine Lese-Zelle zu generieren.
- Verwendung Daten in Notebook schreiben , um eine Schreibzelle zu erstellen.
Schreiben in einen Datensatz scala-write-dataset
In Scala können Sie clientContext
Um Platform-Werte abzurufen und zurückzugeben, entfällt dadurch die Notwendigkeit, Variablen wie var userToken
. Im folgenden Scala-Beispiel: clientContext
wird verwendet, um alle erforderlichen Werte zu definieren und in einen Datensatz zu schreiben.
df.cache()
vor dem Schreiben von Daten kann die Notebook-Leistung erheblich verbessern. Dies kann hilfreich sein, wenn Sie einen der folgenden Fehler erhalten:- Auftrag aufgrund von Staging-Fehler abgebrochen … Kann nur RDDs mit derselben Anzahl von Elementen in jeder Partition komprimieren.
- Remote RPC-Client getrennt und andere Speicherfehler.
- Schlechte Leistung beim Lesen und Schreiben von Datensätzen.
import org.apache.spark.sql.{Dataset, SparkSession}
import com.adobe.platform.token.ClientContext
val spark = SparkSession.builder().master("local").config("spark.sql.warehouse.dir", "/").getOrCreate()
val clientContext = ClientContext.getClientContext()
df1.write.format("com.adobe.platform.query")
.option("user-token", clientContext.getUserToken())
.option("service-token", clientContext.getServiceToken())
.option("ims-org", clientContext.getOrgId())
.option("api-key", clientContext.getApiKey())
.option("sandbox-name", clientContext.getSandboxName())
.option("mode", "batch")
.option("dataset-id", "5e68141134492718af974844")
.save()
clientContext.getUserToken()
.clientContext.getServiceToken()
.clientContext.getOrgId()
.clientContext.getApiKey()
.mode
auf interactive
oder batch
.Erstellen eines lokalen Dataframes scala-create-dataframe
Um einen lokalen Dataframe mit Scala zu erstellen, sind SQL-Abfragen erforderlich. Beispiel:
sparkdf.createOrReplaceTempView("sparkdf")
val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)
Filter ExperienceEvent data scala-experienceevent
Zugreifen auf und Filtern von ExperienceEvent -Datensatz in einem Scala-Notebook erfordert, dass Sie die Datensatz-Identität angeben ({DATASET_ID}
), die IMS-Identität Ihres Unternehmens und die Filterregeln, die einen bestimmten Zeitraum definieren. Ein Filterzeitbereich wird mithilfe der Funktion spark.sql()
definiert, wobei der Funktionsparameter eine SQL-Abfragezeichenfolge ist.
Die folgenden Zellen filtern eine ExperienceEvent Datensatz zu Daten, die ausschließlich zwischen dem 1. Januar 2019 und dem 31. Dezember 2019 existieren.
// Spark (Spark 2.4)
// Turn off extra logging
import org.apache.log4j.{Level, Logger}
Logger.getLogger("org").setLevel(Level.OFF)
Logger.getLogger("com").setLevel(Level.OFF)
import org.apache.spark.sql.{Dataset, SparkSession}
val spark = org.apache.spark.sql.SparkSession.builder().appName("Notebook")
.master("local")
.getOrCreate()
// Stage Exploratory
val dataSetId: String = "{DATASET_ID}"
val orgId: String = sys.env("IMS_ORG_ID")
val clientId: String = sys.env("PYDASDK_IMS_CLIENT_ID")
val userToken: String = sys.env("PYDASDK_IMS_USER_TOKEN")
val serviceToken: String = sys.env("PYDASDK_IMS_SERVICE_TOKEN")
val mode: String = "batch"
var df = spark.read.format("com.adobe.platform.query")
.option("user-token", userToken)
.option("ims-org", orgId)
.option("api-key", clientId)
.option("mode", mode)
.option("dataset-id", dataSetId)
.option("service-token", serviceToken)
.load()
df.createOrReplaceTempView("event")
val timedf = spark.sql("""
SELECT *
FROM event
WHERE timestamp > CAST('2019-01-01 00:00:00.0' AS TIMESTAMP)
AND timestamp < CAST('2019-12-31 23:59:59.9' AS TIMESTAMP)
""")
timedf.show()
Nächste Schritte
In diesem Dokument wurden die allgemeinen Richtlinien für den Zugriff auf Datensätze mit JupyterLab-Notebooks erläutert. Ausführlichere Beispiele zum Abfragen von Datensätzen finden Sie unter Query Service in JupyterLab Notebooks Dokumentation. Weitere Informationen zur Erforschung und Visualisierung Ihrer Datensätze finden Sie im Dokument unter Daten mithilfe von Notebooks analysieren.
Optionale SQL-Flags für Query Service optional-sql-flags-for-query-service
In dieser Tabelle sind die optionalen SQL-Flags aufgeführt, die für Query Service.
-h
, --help
-n
, --notify
-a
, --async
-d
, --display