Configuration de sources de données JDBC pour Snowpark Connect for Spark

Cette section fournit un guide et un exemple de code pour la lecture de données à partir de bases de données externes et l’écriture de données dans des bases de données externes (comme MySQL et PostgreSQL) en utilisant la fonctionnalité de sources de données JDBC Snowpark Connect. Elle couvre à la fois la configuration côté client et celle du Notebook Snowflake.

Partie 1 : Configuration côté client (MySQL)

Cette configuration est requise lors de l’exécution de Snowpark Connect à partir d’une application cliente locale, telle qu’un script Python ou IDE.

Conditions préalables

  1. Environnement d’exécution Java (JRE)/Kit de développement Java (JDK) :

    • Installez un JRE ou un JDK. L’architecture (par exemple, 64 bits) de votre installation Java doit correspondre à l’architecture de votre installation Python.

    • *Exemple de source pour l’installation :*Versions Adoptium Temurin _ (si vous utilisez Java 11).

  2. Définition de la variable d’environnement ``JAVA_HOME`` :

    • Configurez la variable d’environnement JAVA_HOME pour pointer vers le répertoire racine de votre installation Java.

    • Exemple (macOS/Linux) :

export JAVA_HOME=/path/to/your/jdk/home

  1. Définition de la variable d’environnement ``CLASSPATH`` :

    • Ajoutez le chemin d’accès au fichier .jar du pilote JDBC de votre base de données à la variable d’environnement CLASSPATH. Cela permet à l’environnement Java de trouver le pilote nécessaire.

    • Exemple (pour le pilote MySQL) :

export CLASSPATH=$CLASSPATH:/path/to/your/driver/mysql-connector-j-9.2.0.jar

Exemple de code client (lecture depuis MySQL)

Cet exemple montre comment lire une table depuis une base de données MySQL à l’aide de spark_session.read.jdbc().

from pyspark.sql import Row

# Adjust the URL for your server host, port, and database name
MYSQL_JDBC_URL = "jdbc:mysql://localhost/test_db"

# Ensure this driver name matches your version of the JDBC driver
MYSQL_JDBC_DRIVER = "com.mysql.cj.jdbc.Driver"

def test_jdbc_read_from_mysql(self, spark_session):
    # This code snippet uses the Snowpark Connect Spark session
    jdbc_df = spark_session.read.jdbc(
        MYSQL_JDBC_URL,
        "my_schema.my_table",  # Specify your table name in MySQL
        properties={
            "user": "root",           # Your MySQL user name
            "password": "****",       # Your password for MySQL
            "driver": MYSQL_JDBC_DRIVER,
        },
    ).collect()

    # After reading via JDBC, the data is loaded into a temporary table in Snowflake.
    # You can now perform any standard DataFrame operations supported by Snowpark Connect.

Exemple de code client (écriture dans MySQL)

Cet exemple montre comment écrire des données dans une base de données MySQL à l’aide de spark_session.write.jdbc().

from pyspark.sql import Row

# Adjust the URL for your server host, port, and database name
MYSQL_JDBC_URL = "jdbc:mysql://localhost/test_db"

# Ensure this driver name matches your version of the JDBC driver
MYSQL_JDBC_DRIVER = "com.mysql.cj.jdbc.Driver"

def test_jdbc_write_overwrite_to_mysql(self, spark_session):
    # This code snippet uses the Snowpark Connect Spark session
    jdbc_df = spark_session.createDataFrame(
        [
            Row(a=1, b=2.0, c="test1"),
            Row(a=2, b=3.0, c="test2"),
            Row(a=4, b=5.0, c="test3"),
        ]
    )

    jdbc_df.write.jdbc(
        MYSQL_JDBC_URL,
        "my_schema.my_table2",  # Specify your table name in MySQL
        mode="overwrite",
        properties={
            "user": "root",        # Your MySQL user name
            "password": "****",    # Your password for MySQL
            "driver": MYSQL_JDBC_DRIVER,
        },
    )

Partie 2 : Configuration du Snowflake Warehouse Notebook (PostgreSQL)

Cette configuration est utilisée lors de l’exécution de Snowpark Connect directement dans un environnement de Notebook Snowflake.

Étapes de configuration

  • Ajouter le paquet ``snowpark-connect`` :

    • Assurez-vous que le paquet snowflake-snowpark-connect est ajouté à l’environnement de votre notebook.

Ajout du paquet snowflake-snowpark-connect dans le Notebook Snowflake

  • Télécharger et charger le pilote JDBC :

  • Activer les intégrations externes (règle réseau et intégration) :

    • Snowflake nécessite une intégration d’accès externe pour permettre au notebook de communiquer avec des emplacements réseau externes. Vous devez définir une règle réseau pour l’hôte et le port de votre base de données externe.

Configuration des paramètres de règle réseau dans le Notebook Snowflake
Chargement du fichier JAR du pilote JDBC dans le Notebook Snowflake 
-- 1. Create a Network Rule for the external database host and port
CREATE OR REPLACE NETWORK RULE JDBC_READ_NETWORK_RULE
  MODE = EGRESS
  TYPE = HOST_PORT
  VALUE_LIST = ('hh-pgsql-public.ebi.ac.uk:5432'); -- REPLACE with your host:port

-- 2. Create the External Access Integration using the new Network Rule
CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION JDBC_READ_ACCESS_INTEGRATION
  ALLOWED_NETWORK_RULES = (JDBC_READ_NETWORK_RULE)
  ENABLED = true;

-- NOTE: This integration must be referenced/activated within your notebook's settings.

Exemple de code Warehouse Notebook (lecture depuis PostgreSQL)

Cet exemple montre le code Python nécessaire pour initialiser la session, charger le pilote et lire les données depuis PostgreSQL.

from snowflake import snowpark_connect
import jpype

# Initialize the Spark session for Snowpark Connect
spark = snowpark_connect.server.init_spark_session()
df = spark.sql("show schemas").limit(2)
df.show()

# Add the uploaded JDBC driver JAR to the Java Classpath using jpype
# Adjust the path to match the name of the JAR file you uploaded
jpype.addClassPath('/tmp/appRoot/postgresql-42.7.8.jar')

# Using public PostgreSQL DB as an example: https://rnacentral.org/help/public-database
jdbc_df = spark.read.jdbc(
    # Adjust this URL as per your server host, port, and database
    "jdbc:postgresql://hh-pgsql-public.ebi.ac.uk:5432/pfmegrnargs",
    "",  # Empty string for table name when providing a custom query
    properties={
        "user": "reader",                # Your PostgreSQL user name
        "password": "***",               # Your password for PostgreSQL
        "driver": "org.postgresql.Driver",
        # Use the "query" property for a custom SQL statement
        "query": """SELECT
  upi,     -- RNAcentral URS identifier
  taxid,   -- NCBI taxid
  ac       -- external accession
FROM xref
WHERE ac IN ('OTTHUMT00000106564.1', 'OTTHUMT00000416802.1')"""
    },
)

jdbc_df.show()

Exemple de code Warehouse Notebook (écriture dans PostgreSQL)

Cet exemple montre le code Python nécessaire pour initialiser la session, charger le pilote et écrire des données dans PostgreSQL.

from snowflake import snowpark_connect
from pyspark.sql import Row
import jpype

# Initialize the Spark session for Snowpark Connect
spark = snowpark_connect.server.init_spark_session()
df = spark.sql("show schemas").limit(2)
df.show()

# Add the uploaded JDBC driver JAR to the Java Classpath using jpype
# Adjust the path to match the name of the JAR file you uploaded
jpype.addClassPath('/tmp/appRoot/postgresql-42.7.8.jar')

# Create dataframe
jdbc_df = spark.createDataFrame(
    [
        Row(a=1, b=2.0, c="test1"),
        Row(a=2, b=3.0, c="test2"),
        Row(a=4, b=5.0, c="test3"),
    ]
)

# Using public PostgreSQL DB as an example: https://rnacentral.org/help/public-database
jdbc_df.write.jdbc(
    # Adjust this URL as per your server host, port, and database
    "jdbc:postgresql://hh-pgsql-public.ebi.ac.uk:5432/pfmegrnargs",
    "public.my_table2",  # Specify your table name in PostgreSQL
    mode="overwrite",
    properties={
        "user": "writer",                # Your PostgreSQL user name
        "password": "***",               # Your password for PostgreSQL
        "driver": "org.postgresql.Driver",
    },
)

Partie 3 : Configuration de Snowflake Workspace Notebook (PostgreSQL)

Cette configuration est utilisée lors de l’exécution de Snowpark Connect directement dans un environnement Snowflake Workspace Notebook.

Étapes de configuration

Chargement du pilote JDBC dans Snowflake Workspace Notebook

  • Créer une intégration externe :

-- 1. Create a Network Rule for the external database host and port
CREATE OR REPLACE NETWORK RULE JDBC_READ_NETWORK_RULE
  MODE = EGRESS
  TYPE = HOST_PORT
  VALUE_LIST = ('hh-pgsql-public.ebi.ac.uk:5432'); -- REPLACE with your host:port

-- 2. Create the External Access Integration using the new Network Rule
CREATE OR REPLACE EXTERNAL ACCESS INTEGRATION JDBC_READ_ACCESS_INTEGRATION
  ALLOWED_NETWORK_RULES = (JDBC_READ_NETWORK_RULE)
  ENABLED = true;

-- NOTE: This integration must be referenced/activated within your notebook's settings.

  • Activer les intégrations externes (règle réseau et intégration) :

    • Snowflake nécessite une intégration d’accès externe pour permettre au notebook de communiquer avec des emplacements réseau externes. Vous devez définir une règle réseau pour l’hôte et le port de votre base de données externe.

    Activation de l’intégration d’accès externe dans les paramètres de Workspace Notebook

Exemple de code Workspace Notebook (lecture depuis PostgreSQL)

Cet exemple montre le code Python nécessaire pour initialiser la session, charger le pilote et lire les données depuis PostgreSQL.

from snowflake import snowpark_connect
import jpype
import os

# Initialize the Spark session for Snowpark Connect
spark = snowpark_connect.server.init_spark_session()
df = spark.sql("show schemas").limit(2)
df.show()

# Add the uploaded JDBC driver JAR to the Java Classpath using jpype
# Adjust the path to match the name of the JAR file you uploaded
# Copy the driver to /tmp directory
os.system("cp ./postgresql-42.7.8.jar /tmp/postgresql-42.7.8.jar")
jpype.addClassPath('/tmp/postgresql-42.7.8.jar')

# Using public PostgreSQL DB as an example: https://rnacentral.org/help/public-database
jdbc_df = spark.read.jdbc(
    # Adjust this URL as per your server host, port, and database
    "jdbc:postgresql://hh-pgsql-public.ebi.ac.uk:5432/pfmegrnargs",
    "",  # Empty string for table name when providing a custom query
    properties={
        "user": "reader",                # Your PostgreSQL user name
        "password": "***",               # Your password for PostgreSQL
        "driver": "org.postgresql.Driver",
        # Use the "query" property for a custom SQL statement
        "query": """SELECT
  upi,     -- RNAcentral URS identifier
  taxid,   -- NCBI taxid
  ac       -- external accession
FROM xref
WHERE ac IN ('OTTHUMT00000106564.1', 'OTTHUMT00000416802.1')"""
    },
)

jdbc_df.show()

Exemple de code Workspace Notebook (écriture dans PostgreSQL)

Cet exemple montre le code Python nécessaire pour initialiser la session, charger le pilote et écrire des données dans PostgreSQL.

from snowflake import snowpark_connect
from pyspark.sql import Row
import jpype
import os

# Initialize the Spark session for Snowpark Connect
spark = snowpark_connect.server.init_spark_session()
df = spark.sql("show schemas").limit(2)
df.show()

# Add the uploaded JDBC driver JAR to the Java Classpath using jpype
# Adjust the path to match the name of the JAR file you uploaded
# Copy the driver to /tmp directory
os.system("cp ./postgresql-42.7.8.jar /tmp/postgresql-42.7.8.jar")
jpype.addClassPath('/tmp/postgresql-42.7.8.jar')

# Create dataframe
jdbc_df = spark.createDataFrame(
    [
        Row(a=1, b=2.0, c="test1"),
        Row(a=2, b=3.0, c="test2"),
        Row(a=4, b=5.0, c="test3"),
    ]
)

# Using public PostgreSQL DB as an example: https://rnacentral.org/help/public-database
jdbc_df.write.jdbc(
    # Adjust this URL as per your server host, port, and database
    "jdbc:postgresql://hh-pgsql-public.ebi.ac.uk:5432/pfmegrnargs",
    "public.my_table2",  # Specify your table name in PostgreSQL
    mode="overwrite",
    properties={
        "user": "writer",                # Your PostgreSQL user name
        "password": "***",               # Your password for PostgreSQL
        "driver": "org.postgresql.Driver",
    },
)

Sources de données prises en charge

  • SQL Server

  • MySQL

  • PostgreSQL