Toegang tot gegevens in Jupyterlab laptops

Elke ondersteunde kernel biedt ingebouwde functies waarmee u de gegevens van het platform kunt lezen vanuit een gegevensset in een laptop. JupyterLab in Adobe Experience Platform Data Science Workspace ondersteunt momenteel laptops voor Python , R, PySpark en Scala. Ondersteuning voor paginering van gegevens is echter beperkt tot Python - en R-laptops. Deze handleiding is gericht op het gebruik van JupyterLab-laptops voor toegang tot uw gegevens.

Aan de slag

Alvorens deze gids te lezen, te herzien gelieve de JupyterLab gebruikersgidsvoor een inleiding op hoog niveau aan JupyterLab en zijn rol binnen de Wetenschap van Gegevens Workspace.

Gegevenslimieten voor laptops notebook-data-limits

De volgende informatie definieert de maximale hoeveelheid gegevens die kan worden gelezen, het type gegevens dat is gebruikt en het geschatte tijdsbestek waarin de gegevens worden gelezen.

Voor Python en R werd een notebookserver met een RAM van 40 GB gebruikt voor de benchmarks. Voor PySpark en Scala, werd een gegevensbestandcluster gevormd bij 64GB RAM, 8 kernen, 2 DBU met een maximum van 4 arbeiders gebruikt voor de hieronder vermelde benchmarks.

De gegevens in het ExperienceEvent-schema die werden gebruikt, varieerden van 100 (1K) rijen die oplopen tot 1 miljard (1B) rijen. Merk op dat voor PySpark en Spark metriek, een datumspanwijdte van 10 dagen werd gebruikt voor de gegevens XDM.

De ad-hocschemagegevens zijn vooraf verwerkt met Query Service Tabel maken als selectie (CTAS). Deze gegevens varieerden ook in grootte die van duizend (1K) rijen die zich tot één miljard (1B) rijen uitstrekten.

Wanneer wordt de batchmodus gebruikt in combinatie met de interactieve modus mode

Wanneer het lezen van datasets met PySpark en Nota's Scala, hebt u de optie om interactieve wijze of partijwijze te gebruiken om de dataset te lezen. Interactief wordt gemaakt voor snelle resultaten terwijl de partijwijze voor grote datasets is.

Python gegevenslimieten voor laptops

XDM ExperienceEvent schema: U zou een maximum van 2 miljoen rijen (~6.1 GB gegevens op schijf) van XDM gegevens in minder dan 22 minuten moeten kunnen lezen. Als u extra rijen toevoegt, kunnen er fouten optreden.

ad-hoc schema: u zou een maximum van 5 miljoen rijen (~5.6 GB gegevens op schijf) van niet-XDM (ad-hoc) gegevens in minder dan 14 minuten moeten kunnen lezen. Als u extra rijen toevoegt, kunnen er fouten optreden.

R-laptopgegevenslimieten

XDM ExperienceEvent schema: u zou een maximum van 1 miljoen rijen van XDM gegevens (3 GB gegevens op schijf) in onder 13 minuten moeten kunnen lezen.

ad-hoc schema: u zou een maximum van 3 miljoen rijen van ad-hocgegevens (293MB gegevens op schijf) in rond 10 minuten moeten kunnen lezen.

PySpark-laptopgegevenslimieten (Python kernel): pyspark-data-limits

XDM ExperienceEvent schema: Op interactieve wijze zou u een maximum van 5 miljoen rijen (~13.42GB gegevens op schijf) van XDM gegevens in rond 20 minuten moeten kunnen lezen. De interactieve wijze steunt slechts tot 5 miljoen rijen. Als u wenst om grotere datasets te lezen, wordt het geadviseerd u op partijwijze te schakelen. In de batchmodus kunt u maximaal 500 miljoen rijen (~1,31 TB gegevens op schijf) met XDM-gegevens lezen in ongeveer 14 uur.

ad-hoc schema: op Interactieve wijze zou u een maximum van 5 miljoen rijen (~5.36GB gegevens op schijf) van niet-XDM gegevens in minder dan 3 minuten moeten kunnen lezen. In de modus Batch kunt u maximaal 1 miljard rijen (ongeveer 1,05 TB gegevens op schijf) niet-XDM-gegevens lezen in ongeveer 18 minuten.

Spark (Scala kernel) laptopgegevenslimieten: scala-data-limits

XDM ExperienceEvent schema: Op interactieve wijze zou u een maximum van 5 miljoen rijen (~13.42GB gegevens op schijf) van XDM gegevens in rond 18 minuten moeten kunnen lezen. De interactieve wijze steunt slechts tot 5 miljoen rijen. Als u wenst om grotere datasets te lezen, wordt het geadviseerd u op partijwijze te schakelen. In de batchmodus kunt u maximaal 500 miljoen rijen (~1,31 TB gegevens op schijf) met XDM-gegevens lezen in ongeveer 14 uur.

ad-hoc schema: op interactieve wijze zou u een maximum van 5 miljoen rijen (~5.36GB gegevens op schijf) van niet-XDM gegevens in minder dan 3 minuten moeten kunnen lezen. In de batchmodus kunt u maximaal 1 miljard rijen (~1,05 TB gegevens op schijf) niet-XDM-gegevens lezen in ongeveer 16 minuten.

Python-laptops python-notebook

Met Python -laptops kunt u gegevens pagineren wanneer u gegevenssets opent. De voorbeeldcode voor het lezen van gegevens met en zonder paginering wordt hieronder getoond. Voor meer informatie over de beschikbare starter laptops van de Python, bezoek de 🔗 sectie van de Lanceerinrichting JupyterLab binnen de JupyterLab gebruikersgids.

In de onderstaande Python-documentatie worden de volgende concepten beschreven:

Lezen van een dataset in Python python-read-dataset

Zonder paginering:

Het uitvoeren van de volgende code zal de volledige dataset lezen. Als de uitvoering is gelukt, worden de gegevens opgeslagen als een Pandas-dataframe waarnaar door de variabele df wordt verwezen.

# 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()

met paginering:

Het uitvoeren van de volgende code zal gegevens van de gespecificeerde dataset lezen. Paginering wordt bereikt door het beperken en verschuiven van gegevens via respectievelijk de functies limit() en offset() . Het beperken van gegevens heeft betrekking op het maximumaantal gegevenspunten dat moet worden gelezen, terwijl het compenseren verwijst naar het aantal gegevenspunten dat vóór het lezen van gegevens moet worden overgeslagen. Als de leesbewerking met succes wordt uitgevoerd, worden de gegevens opgeslagen als een Pandas-dataframe waarnaar door de variabele df wordt verwezen.

# 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()

Schrijven naar een gegevensset in Python write-python

Als u naar een gegevensset in uw JupyterLab-notitie wilt schrijven, selecteert u het tabblad Gegevenspictogram (hieronder gemarkeerd) in de linkernavigatie van JupyterLab. De mappen Datasets en Schemas worden weergegeven. Selecteer Datasets en klik met de rechtermuisknop en selecteer vervolgens de optie Write Data in Notebook in het vervolgkeuzemenu in de gegevensset die u wilt gebruiken. Onder aan uw laptop wordt een uitvoerbaar code-item weergegeven.

U kunt ook de volgende codecel kopiëren en plakken. Vervang zowel {DATASET_ID} als {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')

Query-gegevens uitvoeren met Query Service in Python query-data-python

JupyterLab op Platform staat u toe om SQL in a Python notitieboekje te gebruiken om tot gegevens door de Dienst van de Vraag van Adobe Experience Platformtoegang te hebben. Toegang tot gegevens via Query Service kan handig zijn voor het verwerken van grote gegevenssets vanwege de superieure runtime. Houd er rekening mee dat het opvragen van gegevens met Query Service een verwerkingstijd van tien minuten heeft.

Alvorens u Query Service in JupyterLab gebruikt, zorg ervoor u een werkend begrip van de Query Service SQL syntaxishebt.

Voor het aanvragen van gegevens met Query Service moet u de naam van de doelgegevensset opgeven. U kunt de noodzakelijke codecellen produceren door de gewenste dataset te vinden gebruikend Data explorer. Klik met de rechtermuisknop op de gegevenssetlijst en klik op Query Data in Notebook om twee codecellen in uw notitieboekje te genereren. Deze twee cellen worden hieronder gedetailleerder beschreven.

Als u Query Service in JupyterLab wilt gebruiken, moet u eerst een verbinding maken tussen uw Python -laptop en Query Service . Dit kan worden bereikt door de eerste gegenereerde cel uit te voeren.

qs_connect()

In de tweede gegenereerde cel moet de eerste regel worden gedefinieerd vóór de SQL-query. Door gebrek, bepaalt de geproduceerde cel een facultatieve variabele (df0) die de vraagresultaten als dataframe van de Pandas bewaart.
het -c QS_CONNECTION argument is verplicht en vertelt de kernel om de SQL vraag tegen Query Service uit te voeren. Zie bijlagevoor een lijst van extra argumenten.

%%read_sql df0 -c QS_CONNECTION
SELECT *
FROM name_of_the_dataset
LIMIT 10
/* Querying table "name_of_the_dataset" (datasetId: {DATASET_ID})*/

De variabelen van de Python kunnen direct binnen een SQL vraag worden van verwijzingen voorzien door koord-geformatteerde syntaxis te gebruiken en de variabelen in krullende steunen ({}), zoals aangetoond in het volgende voorbeeld te verpakken:

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 gegevens python-filter

Als u een ExperienceEvent dataset in een Python notitieboekje wilt openen en filteren, moet u de identiteitskaart van de dataset ({DATASET_ID}) samen met de filterregels verstrekken die een specifieke tijdwaaier gebruikend logische exploitanten bepalen. Wanneer een tijdwaaier wordt bepaald, wordt om het even welke gespecificeerde paginering genegeerd en de volledige dataset wordt overwogen.

Een lijst met filteroperatoren wordt hieronder beschreven:

De volgende cel filtert een ExperienceEvent dataset aan gegevens die uitsluitend tussen 1 januari 2019 en eind december 2019 bestaan.

# 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-laptops r-notebooks

Met R-laptops kunt u gegevens pagineren wanneer u gegevenssets opent. De voorbeeldcode voor het lezen van gegevens met en zonder paginering wordt hieronder getoond. Voor meer informatie over de beschikbare aanzetR laptops, bezoek de 🔗 sectie van de Lanceerinrichting JupyterLab binnen de JupyterLab gebruikersgids.

In de onderstaande R-documentatie worden de volgende concepten beschreven:

Lezen van een dataset in R r-read-dataset

Zonder paginering:

Het uitvoeren van de volgende code zal de volledige dataset lezen. Als de uitvoering is gelukt, worden de gegevens opgeslagen als een Pandas-dataframe waarnaar door de variabele df0 wordt verwezen.

# 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)

met paginering:

Het uitvoeren van de volgende code zal gegevens van de gespecificeerde dataset lezen. Paginering wordt bereikt door het beperken en verschuiven van gegevens via respectievelijk de functies limit() en offset() . Het beperken van gegevens heeft betrekking op het maximumaantal gegevenspunten dat moet worden gelezen, terwijl het compenseren verwijst naar het aantal gegevenspunten dat vóór het lezen van gegevens moet worden overgeslagen. Als de leesbewerking met succes wordt uitgevoerd, worden de gegevens opgeslagen als een Pandas-dataframe waarnaar door de variabele df0 wordt verwezen.

# 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()

Schrijf aan een dataset in R write-r

Als u naar een gegevensset in uw JupyterLab-notitie wilt schrijven, selecteert u het tabblad Gegevenspictogram (hieronder gemarkeerd) in de linkernavigatie van JupyterLab. De mappen Datasets en Schemas worden weergegeven. Selecteer Datasets en klik met de rechtermuisknop en selecteer vervolgens de optie Write Data in Notebook in het vervolgkeuzemenu in de gegevensset die u wilt gebruiken. Onder aan uw laptop wordt een uitvoerbaar code-item weergegeven.

U kunt ook de volgende codecel kopiëren en plakken:

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 gegevens r-filter

Om tot een ExperienceEvent dataset in een notitieboekje van R toegang te hebben en te filtreren, moet u identiteitskaart van de dataset ({DATASET_ID}) samen met de filterregels verstrekken die een specifieke tijdwaaier gebruikend logische exploitanten bepalen. Wanneer een tijdwaaier wordt bepaald, wordt om het even welke gespecificeerde paginering genegeerd en de volledige dataset wordt overwogen.

Een lijst met filteroperatoren wordt hieronder beschreven:

De volgende cel filtert een ExperienceEvent dataset aan gegevens die uitsluitend tussen 1 januari 2019 en eind december 2019 bestaan.

# 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

De documentatie PySpark schetst hieronder de volgende concepten:

sparkSession initialiseren spark-initialize

Voor alle Spark 2.4-laptops moet u de sessie initialiseren met de volgende vaste code.

from pyspark.sql import SparkSession
spark = SparkSession.builder.getOrCreate()

%dataset gebruiken om te lezen en te schrijven met een PySpark 3-laptop magic

Met de introductie van Spark 2.4, wordt %dataset magie geleverd voor gebruik in PySpark 3 (Spark 2.4) laptops. Voor meer details op magische bevelen beschikbaar in de pit IPython, bezoek de IPython magische documentatie.

Gebruik

%dataset {action} --datasetId {id} --dataFrame {df} --mode batch

Beschrijving

Een aangepaste toveropdracht Data Science Workspace voor het lezen of schrijven van een gegevensset van een PySpark -laptop (Python 3-kernel).

Voorbeelden

U kunt de bovenstaande voorbeelden automatisch genereren bij het aanschaffen van JupyterLab met de volgende methode:

Selecteer het tabblad Gegevenspictogram (hieronder gemarkeerd) in de linkernavigatie van JupyterLab. De mappen Datasets en Schemas worden weergegeven. Selecteer Datasets en klik met de rechtermuisknop en selecteer vervolgens de optie Write Data in Notebook in het vervolgkeuzemenu in de gegevensset die u wilt gebruiken. Onder aan uw laptop wordt een uitvoerbaar code-item weergegeven.

Een lokaal gegevensbestand maken pyspark-create-dataframe

Om een lokaal dataframe tot stand te brengen gebruikend PySpark 3 gebruik SQL vragen. Bijvoorbeeld:

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 gegevens pyspark-filter-experienceevent

Voor het verkrijgen en filteren van een ExperienceEvent -dataset in een PySpark-laptop moet u de identiteit van de gegevensset ({DATASET_ID} ), de IMS-identiteit van uw organisatie en de filterregels die een specifieke tijdreeks definiëren. Een het filtreren tijdwaaier wordt bepaald door de functie spark.sql() te gebruiken, waar de functieparameter een SQL vraagkoord is.

De volgende cellen filteren een ExperienceEvent dataset op gegevens die uitsluitend tussen 1 januari 2019 en eind december 2019 bestaan.

# 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-laptops scala-notebook

De onderstaande documentatie bevat voorbeelden van de volgende concepten:

SparkSession initialiseren scala-initialize

Alle Scala-laptops vereisen dat u de sessie initialiseert met de volgende bouwsteencode:

import org.apache.spark.sql.{ SparkSession }
val spark = SparkSession
  .builder()
  .master("local")
  .getOrCreate()

Een gegevensset lezen read-scala-dataset

In Scala, kunt u clientContext invoeren om de waarden van het Platform te krijgen en terug te keren, elimineert dit de behoefte om variabelen zoals var userToken te bepalen. In het onderstaande Scala-voorbeeld wordt clientContext gebruikt om alle vereiste waarden voor het lezen van een gegevensset op te halen en te retourneren.

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)

U kunt het bovenstaande voorbeeld automatisch genereren bij het aanschaffen van JupyterLab met de volgende methode:

Selecteer het tabblad Gegevenspictogram (hieronder gemarkeerd) in de linkernavigatie van JupyterLab. De mappen Datasets en Schemas worden weergegeven. Selecteer Datasets en klik met de rechtermuisknop en selecteer vervolgens de optie Explore Data in Notebook in het vervolgkeuzemenu in de gegevensset die u wilt gebruiken. Onder aan uw laptop wordt een uitvoerbaar code-item weergegeven.
en

Schrijven naar een gegevensset scala-write-dataset

In Scala, kunt u clientContext invoeren om de waarden van het Platform te krijgen en terug te keren, elimineert dit de behoefte om variabelen zoals var userToken te bepalen. In het onderstaande Scala-voorbeeld wordt clientContext gebruikt om alle vereiste waarden die nodig zijn voor het schrijven naar een gegevensset te definiëren en te retourneren.

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()

een lokaal dataframe maken scala-create-dataframe

SQL-query's zijn vereist voor het maken van een lokaal dataframe met Scala. Bijvoorbeeld:

sparkdf.createOrReplaceTempView("sparkdf")

val localdf = spark.sql("SELECT * FROM sparkdf LIMIT 1)

Filter ExperienceEvent gegevens scala-experienceevent

Als u een ExperienceEvent dataset in een Scala-laptop benadert en filtert, moet u de identiteit van de gegevensset ({DATASET_ID}), de IMS-identiteit van uw organisatie en de filterregels die een specifieke tijdreeks definiëren. Een Filtrerende tijdwaaier wordt bepaald door de functie spark.sql() te gebruiken, waar de functieparameter een SQL vraagkoord is.

De volgende cellen filteren een ExperienceEvent dataset op gegevens die uitsluitend tussen 1 januari 2019 en eind december 2019 bestaan.

// 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()

Volgende stappen

In dit document worden de algemene richtlijnen besproken voor toegang tot gegevenssets met JupyterLab-laptops. Voor meer diepgaande voorbeelden bij het vragen van datasets, bezoek de Dienst van de Vraag in JupyterLab notitieboekjesdocumentatie. Voor meer informatie over om uw datasets te onderzoeken en visualiseren, bezoek het document op het analyseren van uw gegevens gebruikend laptops.

Optionele SQL-markeringen voor Query Service optional-sql-flags-for-query-service

In deze tabel staan de optionele SQL-markeringen die kunnen worden gebruikt voor Query Service .