Catégories :

Fonctions de métadonnées

GET_DDL

Renvoie une instruction DDL qui peut être utilisée pour recréer l’objet spécifié. Pour les bases de données et les schémas, GET_DDL est récursif (c’est-à-dire qu’il renvoie les instructions DDL pour recréer tous les objets pris en charge dans la base de données / schéma spécifié).

GET_DDL prend actuellement en charge les types d’objet suivants :

Syntaxe

GET_DDL( '<object_type>' , '[<namespace>.]<object_name>' [ , <use_fully_qualified_names_for_recreated_objects> ] )

Arguments

Obligatoire :

object_type

Spécifie le type d’objet pour lequel le DDL est renvoyé. Les valeurs valides (correspondant aux types d’objet pris en charge) sont :

  • DATABASE

  • FILE_FORMAT

  • FUNCTION (pour les UDFs, y compris les fonctions externes)

  • PIPE

  • POLICY (politiques de masquage et d’accès aux lignes)

  • PROCEDURE (pour les procédures stockées)

  • SCHEMA

  • SEQUENCE

  • STREAM

  • TABLE (y compris pour les tables externes)

  • TAG (balisage d’objets)

  • TASK

  • VIEW (y compris pour les vues matérialisées)

namespace.object_name

Spécifie le nom qualifié complet de l’objet pour lequel le DDL est renvoyé.

L’espace de noms est la base de données et / ou le schéma dans lequel l’objet réside :

  • Non utilisé pour les bases de données.

  • Pour les schémas, prend la forme de la database.

  • Pour les objets de schéma (tables, vues, flux, tâches, séquences, formats de fichier, canaux, politiques et UDFs), prend la forme d’un database.schema ou d’un schema.

L’espace de noms est facultatif si une base de données et un schéma sont actuellement utilisés dans la session utilisateur ; sinon, il est obligatoire.

Facultatif :

use_fully_qualified_names_for_recreated_objects

Si TRUE, les instructions DDL générées utilisent des noms complets pour les objets à recréer.

Par défaut : FALSE.

Note

Cela n’affecte pas les noms des autres objets référencés dans l’instruction DDL (par exemple le nom d’une table référencée dans une définition de vue).

Renvoie

Renvoie une chaîne (VARCHAR) contenant le texte de l’instruction DDL qui a créé l’objet.

Pour les UDFs et les procédures stockées, le résultat peut être légèrement différent de la DDL d’origine. Par exemple, si l’UDF ou la procédure stockée contient le code JavaScript, les caractères de délimitation entourant le code JavaScript peuvent être différents. De même, si l’instruction CREATE PROCEDURE d’origine ne spécifiait pas EXECUTE AS OWNER ni EXECUTE AS CALLER, le résultat de GET_DDL inclurait EXECUTE AS OWNER, car il s’agit de la valeur par défaut.

Notes sur l’utilisation

Les remarques suivantes s’appliquent à tous les objets pris en charge :

  • object_type et object_name (y compris namespace si spécifié) doivent être entourés de guillemets simples.

  • object_type, TABLE et VIEW sont interchangeables. Si un type d’objet TABLE est spécifié et que l’objet spécifié par nom est une vue, la fonction renvoie le DDL pour la vue et inversement.

  • If object_type is FUNCTION (i.e. UDF) and the UDF has arguments, you must include the argument data types as part of the function name, in the form of 'function_name( [ arg_data_type [ , ... ] ] )', where function_name is the name of the function and arg_data_type is the data type of the argument.

  • Si object_type est PROCEDURE et que la procédure stockée présente des arguments, vous devez inclure les types de données d’argument dans le nom de la fonction, sous la forme de 'procedure_name( [ arg_data_type [ , ... ] ] )'.

  • L’interrogation de cette fonction pour la plupart des types d’objets Snowflake nécessite les mêmes autorisations minimales que celles requises pour visualiser l’objet (en utilisant DESCRIBE <objet> ou SHOW <objets>). Snowflake limite la visualisation d’objets spéciaux tels que les vues sécurisées au propriétaire (c’est-à-dire le rôle ayant le privilège OWNERSHIP sur l’objet).

Les remarques suivantes sont spécifiques aux objets de vue :

  • Le résultat de la requête toujours :

    • Renvoie le texte SQL en minuscules pour create or replace view, même si la casse dans l’instruction SQL d’origine utilisée pour créer la vue était en majuscules ou mixte.

    • Inclut la clause OR REPLACE.

    • Inclut la propriété SECURE si la vue est sécurisée.

    • Exclut le paramètre de vue COPY GRANTS même si l’instruction CREATE VIEW d’origine spécifie le paramètre COPY GRANTS.

    • Génère la liste des colonnes.

      Si une politique de masquage est définie sur une colonne, le résultat spécifie la politique de masquage pour la colonne.

    • Supprime les commentaires SQL en ligne avant le corps de la vue (c’est-à-dire AS). Par exemple, dans le code suivant, le commentaire qui précède immédiatement la clause AS est supprimé :

      create view view_t1
          -- GET_DDL() removes this comment.
          AS
          select * from t1;
      
  • Si la vue possède une politique de masquage sur une ou plusieurs de ses colonnes ou une politique d’accès aux lignes et que le rôle qui exécute la requête GET_DDL ne possède pas le privilège global APPLY MASKING POLICY ou APPLY ROW ACCESS POLICY, selon le cas, Snowflake remplace le nom de la politique par #unknown_policy.

    S’il n’est pas supprimé avant de recréer la vue, le texte #unknown_policy fait échouer l’instruction CREATE VIEW. L’utilisation de ce texte a pour but d’indiquer que la colonne ou la vue est protégée par une politique.

    Si ce texte est présent dans le résultat de la requête GET_DDL, avant de recréer la vue, consultez votre administrateur de gouvernance interne pour déterminer les politiques nécessaires pour les colonnes ou la vue, modifiez le résultat de la requête GET_DDL, puis recréez la vue.

Détails du classement

  • Collation information is included in the input.

Exemples

Renvoyer le DDL utilisé pour créer une vue nommée books_view :

select get_ddl('view', 'books_view');
+-----------------------------------------------------------------------------+ 
| GET_DDL('VIEW', 'BOOKS_VIEW')                                               |
|-----------------------------------------------------------------------------|
|                                                                             |
| create or replace view BOOKS_VIEW as select title, author from books_table; |
|                                                                             |
+-----------------------------------------------------------------------------+

Renvoyer le DDL utilisé pour créer un schéma nommé books_schema et les objets du schéma (la table books_table et la vue books_view) :

select get_ddl('schema', 'books_schema');
+-----------------------------------------------------------------------------+ 
| GET_DDL('SCHEMA', 'BOOKS_SCHEMA')                                           |
|-----------------------------------------------------------------------------|
| create or replace schema BOOKS_SCHEMA;                                      |
|                                                                             |
| create or replace TABLE BOOKS_TABLE (                                       |
| 	ID NUMBER(38,0),                                                      |
| 	TITLE VARCHAR(255),                                                   |
| 	AUTHOR VARCHAR(255)                                                   |
| );                                                                          |
|                                                                             |
| create or replace view BOOKS_VIEW as select title, author from books_table; |
|                                                                             |
+-----------------------------------------------------------------------------+

Renvoyer le DDL qui utilise des noms complets pour les objets à recréer :

select get_ddl('schema', 'books_schema', true);
+---------------------------------------------------------------------------------------------------+
| GET_DDL('SCHEMA', 'BOOKS_SCHEMA', TRUE)                                                           |
|---------------------------------------------------------------------------------------------------|
| create or replace schema BOOKS_DB.BOOKS_SCHEMA;                                                   |
|                                                                                                   |
| create or replace TABLE BOOKS_DB.BOOKS_SCHEMA.BOOKS_TABLE (                                       |
| 	ID NUMBER(38,0),                                                                            |
| 	TITLE VARCHAR(255),                                                                         |
| 	AUTHOR VARCHAR(255)                                                                         |
| );                                                                                                |
|                                                                                                   |
| create or replace view BOOKS_DB.BOOKS_SCHEMA.BOOKS_VIEW as select title, author from books_table; |
|                                                                                                   |
+---------------------------------------------------------------------------------------------------+

Note

Comme illustré dans l’exemple ci-dessus, l’instruction DDL n’utilise pas de nom complet pour la table utilisée pour créer la vue. Pour résoudre le nom de cette table, Snowflake utilise le nom de la base de données et le nom du schéma pour la vue.

Renvoie le DDL utilisé pour créer un UDF nommé multiply ayant deux paramètres de type NUMBER :

select get_ddl('function', 'multiply(number, number)');

--------------------------------------------------+
 GET_DDL('FUNCTION', 'MULTIPLY(NUMBER, NUMBER)')  |
--------------------------------------------------+
 CREATE OR REPLACE "MULTIPLY"(A NUMBER, B NUMBER) |
 RETURNS NUMBER(38,0)                             |
 COMMENT='multiply two numbers'                   |
 AS 'a * b';                                      |
--------------------------------------------------+

Renvoyer la DDL pour créer une procédure stockée nommée stproc_1 comportant un paramètre de type FLOAT :

SELECT GET_DDL('procedure', 'stproc_1(float)');
+---------------------------------------------------+
| GET_DDL('PROCEDURE', 'STPROC_1(FLOAT)')           |
|---------------------------------------------------|
| CREATE OR REPLACE PROCEDURE "STPROC_1"("F" FLOAT) |
| RETURNS FLOAT                                     |
| LANGUAGE JAVASCRIPT                               |
| EXECUTE AS OWNER                                  |
| AS '                                              |
| ''return F;''                                     |
| ';                                                |
+---------------------------------------------------+

renvoyer la DDL pour créer une politique de masquage nommée employee_ssn_mask pour masquer les numéros de sécurité sociale. Les valeurs masquées sont visibles, sauf si le rôle actuel de l’utilisateur est PAYROLL.

select get_ddl('policy', 'employee_ssn_mask');

---------------------------------------------------------------------------+
                   GET_DDL('POLICY', 'EMPLOYEE_SSN_MASK')                  |
---------------------------------------------------------------------------+
create masking policy employee_ssn_mask as (val string) returns string ->  |
case                                                                       |
  when current_role() in ('PAYROLL')                                       |
  then val                                                                 |
  else '******'                                                            |
end;                                                                       |
---------------------------------------------------------------------------+
Revenir au début