Qu’est-ce qu’un modèle dimensionnel et remark l’implémenter sur la plate-forme Databricks Lakehouse

Oracle est une technologie bien connue pour l’hébergement de options Enterprise Information Warehouse. Cependant, de nombreux shoppers aiment Optimum et le Providers Américains de la Citoyenneté et de l’Immigration a choisi de migrer vers Plate-forme Databricks Lakehouse pour tirer parti de la puissance des données, de l’analyse et de l’IA sur une seule plateforme à grande échelle et pour fournir plus rapidement de la valeur commerciale. Par exemple, le système d’entrepôt de données basé sur Oracle sur website d’Optum avait du mal à traiter et analyser rapidement les données. Avec Azure Databricks, ils ont multiplié par 2 les performances du pipeline de données, permettant une livraison plus rapide des résultats aux hôpitaux, leur faisant économiser des hundreds of thousands de {dollars} en revenus potentiellement perdus.

La migration d’Oracle vers Databricks implique plusieurs étapes, les plus critiques sont :

Dans cet article de weblog, nous nous concentrerons sur la conversion du code propriétaire PL/SQL en un code python commonplace ouvert et tirerons parti de PySpark pour les prices de travail ETL et de la puissance de cost de travail d’analyse de données de Databricks SQL.

Défi de la conversion de PL/SQL en PySpark

Au fur et à mesure que le besoin de créer des pipelines de données et ETL augmentait, chaque base de données avait besoin d’un wrapper de langage de programmation pour avoir le contexte pour transmettre les paramètres et gérer les ensembles de données par programme. Au lieu d’utiliser des requirements open supply comme Python, la plupart des bases de données ont créé leurs propres langages propriétaires. PL/SQL est la model d’Oracle des extensions de langage de programmation sur SQL. Il exploite le langage SQL avec des éléments procéduraux (paramètres, variables, ensembles de données sous forme de curseurs, directions conditionnelles, boucles, blocs d’exception, and many others.). Son langage propriétaire et ses extensions ont été développés au fil des ans et ont leurs propres spécificités qui peuvent rendre difficile la conversion vers un langage de programmation open supply commonplace, largement utilisé et complet comme Python.

Un exemple de ceci est les packages PL/SQL fournis (packages DBMS_ ou UTL_ and many others.) et les varieties définis par l’utilisateur qui peuvent être utilisés comme objets pour les varieties de colonne (objets ou collections définis comme un sort de colonne) ce qui rend la migration assez complexe. Ces fonctionnalités spécifiques à Oracle et de nombreuses autres doivent être prises en compte lors de la conversion du code vers Apache Spark™.

De nombreuses organisations ont créé des tâches de traitement de données ETL en écrivant des procédures et des fonctions PL/SQL encapsulées dans des packages qui s’exécutent sur une base de données Oracle. Vous pouvez convertir ces travaux PL/SQL en python open supply et Spark et les exécuter dans des blocs-notes Databricks ou Delta Stay Tables sans aucune complexité de PL/SQL et les exécuter sur le calcul sans serveur à la demande Databricks moderne.

Migrez le code PL/SQL vers PySpark pour vos pipelines ETL

Le processus ETL est principalement utilisé pour :

• Ingestion de données provenant de plusieurs sources
• Validation, nettoyage et transformation des données
• Chargement des données dans différentes couches de données (bronze, silver, gold / Operational Information Retailer, Information Warehouse, Information Marts… selon l’structure des données)

Dans les bases de données Oracle, PL/SQL est généralement utilisé pour valider/transformer les données en place. Selon l’structure de la base de données Oracle, les données se déplacent à partir de divers conteneurs qui peuvent être un schéma utilisateur et/ou une base de données enfichable.
Voici un exemple d’implémentation de base de données Oracle typique qui prend en cost un entrepôt de données utilisant PL/SQL pour ETL.

Passer d’Oracle et PL/SQL à Databricks Lakehouse tirera parti de nombreux points clés :

• PySpark fournira une bibliothèque commonplace en Python, qui permettra de traiter diverses sources de données à grande échelle directement vers l’ODS sans avoir à matérialiser une desk dans la zone de staging. Cela peut être fait avec un pocket book python planifié régulièrement avec les flux de travail Databricks.
• Tableaux en direct Delta offrira la possibilité d’implémenter l’ensemble du pipeline ETL dans un bloc-notes python ou SQL avec un contrôle de la qualité des données (Gérez la qualité des données avec Delta Stay Tables) et sont capables de traiter les données en batch ou en temps réel (Traiter les flux de données avec Delta Stay Tables).

Quelle que soit la fonctionnalité utilisée, la logique PL/SQL sera migrée vers du code python ou SQL. Par exemple, les fonctions PL/SQL seront traduites en PySpark et sont appelées directement ou by way of une fonction python définie par l’utilisateur (voir ce lien sur l’utilisation de Python UDF dans Delta Stay Tables : Livre de delicacies Delta Stay Tables )

Migrer le code PL/SQL vers Databricks SQL ou Python UDF

Databricks SQL est utilisé pour exécuter de nombreuses prices de travail SQL et l’une d’entre elles consiste à exécuter des requêtes d’analyse basées sur des données hébergées sur le Lakehouse. Ces requêtes d’analyse peuvent nécessiter l’exécution de certaines fonctions sur ces tables (expurgation de données, and many others.).
Ces fonctions sont généralement adressées dans Oracle par des fonctions PL/SQL ou des fonctions de packages et seront migrées au cours du processus.

Python UDF sur Databricks SQL exploite les prices de travail SQL traditionnelles avec les fonctionnalités apportées par le langage python.

Exemples de migration de code PL/SQL

Cette part sera dédiée à quelques exemples de migration de code d’Oracle PL/SQL vers Databricks. Basé sur les meilleures pratiques et nos recommandations, chaque exemple dépend du choix d’implémentation. (PySpark dans un processus ETL, Python UDF dans une cost de travail analytique Databricks SQL).

Curseurs dynamiques utilisant le package deal Oracle fourni par DBMS_SQL

Dans Oracle, un curseur est un pointeur vers une zone SQL privée qui stocke des informations sur le traitement d’une instruction SELECT ou DML spécifique. Un curseur construit et géré par le noyau Oracle by way of PL/SQL est un curseur implicite. Un curseur que vous construisez et gérez est un curseur explicite.

Dans Oracle, les curseurs peuvent être paramétrés en utilisant des chaînes dynamiques pour l’instruction SQL, mais cette method peut entraîner des problèmes d’injection SQL, c’est pourquoi il est préférable d’utiliser le package deal PL/SQL fourni par DBMS_SQL ou les directions EXECUTE IMMEDIATE qui aideront à créer des directions dynamiques. Un curseur peut très facilement être converti en Spark DataFrame.

L’exemple suivant montre remark nous transformons des directions SQL dynamiques créées avec un package deal PL/SQL fourni par Oracle en PySpark.

Voici le code SQL PL/SQL dans Oracle.

create or exchange operate get_prod_name(in_pid in quantity) return VARCHAR2
as
    sql_stmt VARCHAR2(256);
    l_i_cursor_id   INTEGER;
    l_n_rowcount    NUMBER;
    l_vc_prod_name VARCHAR2(30);
BEGIN
    sql_stmt := 'choose prod_name from merchandise the place prod_id=:pid FETCH NEXT 1 ROWS ONLY'; 
    l_i_cursor_id:=dbms_sql.open_cursor;
    
    dbms_sql.parse(l_i_cursor_id,sql_stmt, dbms_sql.native);

    dbms_sql.bind_variable(l_i_cursor_id,'pid', in_pid);
    
    dbms_sql.define_column(l_i_cursor_id,1, l_vc_prod_name,30);
    
    l_n_rowcount:= dbms_sql.execute_and_fetch(l_i_cursor_id);
    
    dbms_sql.column_value(l_i_cursor_id,1,l_vc_prod_name);
    dbms_sql.close_cursor(l_i_cursor_id);
    
    return l_vc_prod_name;
END;
/

Voici le code qui exécute la même fonctionnalité dans PySpark.

import pyspark.sql.capabilities as f

def get_prod_name(in_pid:int) -> str:
  sql_stmt="""choose PROD_NAME 
     from merchandise 
     the place PROD_ID={} 
     LIMIT 1""".format(in_pid)
  ret=spark.sql(sql_stmt).gather()(0)("PROD_NAME")
  return ret

print(get_prod_name(20))

# Perform name
print(get_prod_name(20))

Migrations de collections vers Python

Dans Oracle PL/SQL, de nombreux varieties de assortment et d’enregistrement existent.

Ceux-ci peuvent être migrés vers des éléments Python, qu’ils soient exécutés en tant que tâches à l’aide de PySpark à des fins ETL, ou vers Python UDF dans Databricks SQL.

Un tableau associatif est un ensemble de paires clé-valeur. Chaque clé est un index distinctive utilisé pour localiser la valeur associée avec la syntaxe variable_name(index).

Le sort de données de l’index peut être un sort de chaîne (VARCHAR2, VARCHAR, STRING ou LONG) ou PLS_INTEGER. Les index sont stockés dans l’ordre de tri et non dans l’ordre de création. La meilleure façon de migrer un tableau associé vers python (ou PySpark) est d’utiliser une construction de dictionnaire.

Voici à quoi ressemble le code en PL/SQL :

DECLARE
  -- Associative array listed by string:
  
  TYPE inhabitants IS TABLE OF NUMBER  
    INDEX BY VARCHAR2(64);           
  
  city_population  inhabitants;   
  i  VARCHAR2(64);
BEGIN
  -- Add components (key-value pairs) to associative array:
 
  city_population('Smallville')  := 2000;
  city_population('Midland')     := 750000;
  city_population('Megalopolis') := 1000000;
 
  -- Change worth related to key 'Smallville':
 
  city_population('Smallville') := 2001;
 
  -- Print associative array:
 
  i := city_population.FIRST;  -- Get first component of array
 
  WHILE i IS NOT NULL LOOP
    DBMS_Output.PUT_LINE
      ('Inhabitants of ' || i || ' is ' || city_population(i));
    i := city_population.NEXT(i);  -- Get subsequent component of array
  END LOOP;
END;
/

Ci-dessous, un exemple sur la façon de convertir des tableaux associatifs en python à partir de PL/SQL :

# Declare dictionary and add components
city_population={'Smallville':2000, 'Midland':750000, 'Megalopolis':1000000}

# modify a component
city_population('Smallville')=1750

# get the primary component of dictionary
elt_cnt=checklist(city_population.keys())(0)

# print dictionary content material
for okay,v in city_population.objects():
  print(f"Inhabitants of {okay} is {v}")

Caviardage des données

Sur la couche sémantique d’un entrepôt de données, il est parfois nécessaire de caviarder des données sensibles. Pour cela, des fonctions sont très souvent utilisées pour mettre en œuvre le processus de rédaction des données.

Dans une base de données Oracle, vous pouvez utiliser l’possibility de sécurité avancée pour la rédaction des données ou un PL/SQL qui implémentera la rédaction. Ces deux methods peuvent être utilisées par nos équipes de migration, mais si la base de données supply utilise PL/SQL pour ce faire, la meilleure resolution sera d’utiliser Python UDF dans Databricks SQL.

Les UDF Python permettent aux utilisateurs d’écrire du code Python et de l’invoquer by way of une fonction SQL de manière easy, sécurisée et entièrement gouvernée, apportant la puissance de Python à Databricks SQL.

Dans l’exemple suivant, nous avons traduit une fonction PL/SQL qui masque les noms de produits lorsque le prix catalogue est supérieur à 100 à l’aide de la fonction UDF python.

Codez en PL/SQL comme ci-dessous :

CREATE OR REPLACE FUNCTION simple_redaction(
  enter VARCHAR2,
  worth NUMBER)
return varchar2
as
BEGIN
  IF (worth > 100) THEN
    RETURN SUBSTR(enter,0,1)||'*****'||SUBSTR(enter,-1);
  ELSE
    RETURN enter;
  END IF;
END;
/

SQL> choose simple_redaction(prod_name, list_price) as  
     r_prod_name, list_price 
     from product;

R_PROD_NAME		       LIST_PRICE
------------------------------ ----------
product 1			     10.5
p*****2 			            103.1
product 3			     5.99
product 4			    12.35
product 5			       35
e*****t 			             1400

L’UDF Python sera comme ci-dessous :

create or exchange operate simple_redaction(_input string, 
                 _price float)
returns STRING
language python
as $$
if _price >100:
  return (_input(0)+"*****"+_input(-1))
else:
  return _input
$$;



choose simple_redaction(prod_name, list_price) as r_prod_name, list_price from product;

--------------------------------
| r_prod_name	| list_price   |
--------------------------------
| product 1	| 10.5         |
| p*****2	| 103.1        |
| product 3	| 5.99         | 
| product 4	| 12.35        |
| product 5	| 35.0         |
| e*****t	| 1400.0       |
--------------------------------

Planification de votre migration PL/SQL

Databricks et nos partenaires SI/consultants peuvent vous aider avec une évaluation method détaillée de la migration qui inclut votre structure cible, une évaluation method de votre code existant, comme le nombre d’objets à migrer, leur classification de complexité globale, les approches methods des données, le code et la modernisation des rapports, and many others. Nos shoppers peuvent exécuter la migration manuellement en interne ou accélérer leur migration en utilisant une conversion de code automatisée de PL/SQL vers PySpark.

Approche de migration automatisée

La pratique de migration d’entrepôt de données chez Databricks est en plein essor, et nous avons plusieurs partenaires ISV et Consulting/SI qui peuvent aider aux migrations EDW. Les partenaires d’ingestion de données comme Fivetran, Qlik, Arcion peuvent aider à migrer les données en temps réel à l’aide de CDC d’Oracle vers Databricks et les partenaires ETL facultatifs à faible code/code comme Matillion et Prophecy peuvent également aider si les procédures stockées doivent être converties en ETL visuel mappages. Consultez la liste complète de nos Partenaires ISV ici.

Avec l’aide d’outils d’évaluation de plate-forme hérités et d’accélérateurs de conversion automatique de code, Databricks Skilled Providers et plusieurs de nos Migrations Partenaires Brickbuilder SI peut également migrer le code PL/SQL rapidement et efficacement vers les blocs-notes Databricks natifs.

Voici un exemple de démonstration de conversion de code automatisée de PL/SQL à PySpark par BladeBridgenotre partenaire de conversion ISV.

LeapLogic est un autre partenaire qui dispose également d’une évaluation automatisée et de convertisseurs de code de divers EDW vers Databricks. Voici une démo de leur Outil de conversion Oracle aux Databricks.

La plupart des partenaires de conseil/SI utilisent des outils de conversion automatisés similaires, sauf s’il s’agit d’une modernisation et d’une refonte complètes.

Que vous choisissiez de moderniser votre plateforme Legacy Oracle EDW en interne ou avec l’aide d’un partenaire conseil, des spécialistes de la migration Databricks et équipe de providers professionnels sont là pour vous aider tout au lengthy du chemin.
Veuillez voir ceci Web page de migration EDW pour plus d’informations et les offres de migration des partenaires.

N’hésitez pas à contacter l’équipe Databricks pour une évaluation Oracle Migration personnalisée.

Commencez à migrer vos premiers morceaux de code vers Databricks

Essayez Databricks gratuitement pendant 14 jours.