Lire en anglais

Partager via


Paramètres pour Odbc.DataSource

La fonction Odbc.DataSource prend deux paramètres : une connectionString pour votre pilote, et un enregistrement options qui vous permet de remplacer différents comportements de pilote. Grâce à l'enregistrement d’options, vous pouvez remplacer les capacités et autres informations signalées par le pilote, contrôler le comportement du navigateur, et affecter les requêtes SQL générées par le moteur M.

Les champs d’enregistrement d’options pris en charge se répartissent en deux catégories : ceux qui sont publics et toujours disponibles, et ceux qui ne sont disponibles que dans un contexte d’extensibilité.

La table suivante décrit les champs publics dans l’enregistrement d’options.

Champ Description
CommandTimeout Une valeur de durée qui contrôle le temps pendant lequel la requête côté serveur est autorisée à s’exécuter avant d’être annulée.

Valeur par défaut : 10 minutes
ConnectionTimeout Une valeur de durée qui contrôle le temps d’attente avant l’abandon d’une tentative de connexion au serveur.

Valeur par défaut : 15 secondes
CreateNavigationProperties Une valeur logique qui détermine le nécessité de générer des propriétés de navigation sur les tables retournées. Les propriétés de navigation sont basées sur des relations de clé étrangère signalées par le pilote. Ces propriétés s’affichent sous la forme de colonnes « virtuelles » qui peuvent être développées dans l’éditeur de requête, en créant la jointure appropriée.

Si le calcul des dépendances de clé étrangère est une opération coûteuse pour votre pilote, vous pouvez définir cette valeur sur false.

Valeur par défaut : true.
HierarchicalNavigation Valeur logique déterminant la nécessité d’afficher les tables regroupées par leurs noms de schéma. Lorsque la valeur est false, les tables sont affichées dans une liste plate sous chaque base de données.

Valeur par défaut : false
SqlCompatibleWindowsAuth Valeur logique déterminant la nécessité de produire une chaîne de connexion compatible avec SQL Server lors de l’utilisation de l’Authentification Windows—Trusted_Connection=Yes.

Si votre pilote prend en charge l’Authentification Windows mais nécessite des paramètres supplémentaires ou alternatifs dans votre chaîne de connexion, vous devez définir cette valeur sur false et utiliser le champ d’enregistrement d’options CredentialConnectionString décrit dans le tableau suivant.

Valeur par défaut : true.

Le tableau suivant décrit les champs d’enregistrement d’options disponibles uniquement via une extensibilité. Les champs qui ne sont pas de simples valeurs littérales sont décrits dans des sections ultérieures.

Champ Description
AstVisitor Enregistrement contenant une ou plusieurs substitutions pour contrôler la génération de requête SQL. L’usage le plus courant de ce champ est pour fournir une logique pour générer une clause LIMIT/OFFSET pour les pilotes qui ne prennent pas en charge la clause TOP.

Les champs sont Constant et LimitClause.

Informations supplémentaires : Substitution d’AstVisitor
CancelQueryExplicitly Valeur logique demandant au moteur M d’annuler explicitement tout appel en cours d’exécution via le pilote ODBC avant de mettre un terme à la connexion au serveur ODBC.

Ce champ est utile quand l’exécution de requête est gérée indépendamment des connexions réseau au serveur, par exemple, dans certains déploiements Spark. Dans la plupart des cas, cette valeur n’a pas besoin d’être définie, car la requête dans le serveur est annulée quand la connexion réseau au serveur est arrêtée.

Valeur par défaut : false
ClientConnectionPooling Valeur logique activant le regroupement de connexions côté client pour le pilote ODBC. La plupart des pilotes définiront cette valeur sur true.

Valeur par défaut : false
CredentialConnectionString Valeur de texte ou d’enregistrement utilisée pour spécifier des propriétés de chaîne de connexion associées aux informations d’identification.
HideNativeQuery Valeur logique contrôlant si le connecteur affiche ou non des instructions SQL générées dans l’expérience utilisateur Power Query. Cette valeur ne devrait être définie sur true que si la source de données principale prend en charge SQL-92 en mode natif.

Valeur par défaut : false
ImplicitTypeConversions Valeur de table contenant des conversions de types implicites prises en charge par votre pilote ou serveur principal. Les valeurs de cette table s’ajoutent aux conversions signalées par le pilote lui-même.

Ce champ est généralement utilisé avec le champ SQLGetTypeInfo lors de la modification des informations de type de données signalées par le pilote.
OnError Fonction de gestion des erreurs qui reçoit un paramètre errorRecord de type record.

Des utilisations courantes de cette fonction sont la gestion d’échecs de connexion SSL, la fourniture d’un lien de téléchargement si votre pilote n’est pas trouvé sur le système, et le signalement d’erreurs d’authentification.
SoftNumbers Permet au moteur M de sélectionner un type de données compatible quand la conversion entre deux types numériques spécifiques n’est pas déclarée comme prise en charge dans les fonctionnalités SQL_CONVERT_*.

Valeur par défaut : false
SqlCapabilities Enregistrement fournissant diverses substitutions de fonctionnalités de pilote, et un moyen de spécifier des fonctionnalités qui ne sont pas exprimées via ODBC 3.8.

Informations supplémentaires : Substitution de SqlCapabilities
SQLColumns Fonction permettant de modifier les métadonnées de colonne retournées par la fonction SQLColumns.

Informations supplémentaires : Substitution de SQLColumns
SQLGetFunctions Enregistrement permettant de remplacer des valeurs retournées par des appels à SQLGetFunctions.

L’usage courant de ce champ est pour désactiver l’utilisation d’une liaison de paramètre, ou spécifier que les requêtes générées devraient utiliser la fonction CAST plutôt que la fonction CONVERT.

Informations supplémentaires : Substitution de SQLGetFunctions
SQLGetInfo Enregistrement permettant de remplacer des valeurs retournées par des appels à SQLGetInfo.

Informations supplémentaires : Substitution de SQLColumns
SQLGetTypeInfo Table ou fonction retournant une table qui remplace des informations de type retournées par SQLGetTypeInfo.

Lorsque la valeur est définie sur une table, la valeur remplace complètement les informations de type signalées par le pilote. La fonction SQLGetTypeInfo ne sera pas appelée.

Quand la valeur est définie sur une fonction, votre fonction reçoit le résultat de l’appel d’origine à SQLGetTypeInfo, ce qui vous permet de modifier la table.

Ce champ est généralement utilisé quand il existe une discordance entre les types de données signalés par SQLGetTypeInfo et SQLColumns.

Informations supplémentaires : Substitution de SQLGetTypeInfo
SQLTables Fonction permettant de modifier les métadonnées de table retournées par un appel à SQLTables.
TolerateConcatOverflow Autorise la concaténation de valeurs de texte même si le résultat risque d’être tronqué pour tenir dans la plage d’un type disponible.

Par exemple, lors de la concaténation d’un champ VARCHAR(4000) avec un champ VARCHAR(4000) sur un système qui prend en charge une taille de VARCHAR maximale de 4000 et aucun type CLOB, la concaténation est pliée même si le résultat risque d’être tronqué.

Valeur par défaut : false
UseEmbeddedDriver (utilisation interne) : valeur logique déterminant si le pilote ODBC doit être chargé à partir d’un répertoire local (à l’aide d’une nouvelle fonctionnalité définie dans la spécification ODBC 4.0). Cette valeur est généralement définie uniquement par des connecteurs créés par Microsoft qui sont intégrés dans Power Query.

Lorsque la valeur est false, le gestionnaire de pilotes ODBC système est utilisé pour localiser et charger le pilote.

La plupart des connecteurs ne devraient pas avoir besoin de définir ce champ.

Valeur par défaut : false

Substitution d’AstVisitor

Le champ AstVisitor est défini via l’enregistrement d’options Odbc.DataSource. Il est utilisé pour modifier des instructions SQL générées pour des scénarios de requête spécifiques.

Notes

Les pilotes qui prennent en charge les clauses LIMIT et OFFSET (plutôt que la clause TOP) souhaiteront fournir une substitution de LimitClause pour AstVisitor.

Constant

La fourniture d’une substitution pour cette valeur est déconseillée et pourra être supprimée d’implémentations futures.

LimitClause

Ce champ est une fonction qui reçoit deux arguments Int64.Type (skip, take), et retourne un enregistrement avec deux champs de texte (Text, Location).

LimitClause = (skip as nullable number, take as number) as record => ...

Le paramètre skip est le nombre de lignes à ignorer (c’est-à-dire l’argument pour la fonction OFFSET). Si aucun décalage n’est spécifié, la valeur de skip est null. Si votre pilote prend en charge la clause LIMIT, mais pas la clause OFFSET, la fonction LimitClause devrait retourner une erreur de type Non implémenté (...) quand la valeur de skip est supérieure à 0.

Le paramètre take est le nombre de lignes à prendre (c’est-à-dire l’argument pour la clause LIMIT).

Le champ Text du résultat contient le texte SQL à ajouter à la requête générée.

Le champ Location spécifie où insérer la clause. Le tableau ci-dessous décrit les valeurs prises en charge.

Valeur Description Exemple
AfterQuerySpecification La clause LIMIT est placée à la fin du SQL généré.

Il s’agit de la syntaxe de LIMIT la plus couramment prise en charge.
SELECT a, b, c

FROM table

WHERE a > 10

LIMIT 5
BeforeQuerySpecification La clause LIMIT est placée devant l’instruction SQL générée. LIMIT 5 ROWS

SELECT a, b, c

FROM table

WHERE a > 10
AfterSelect La clause LIMIT vient après l’instruction SELECT et tous les modificateurs (tels que DISTINCT). SELECT DISTINCT LIMIT 5 a, b, c

FROM table

WHERE a > 10
AfterSelectBeforeModifiers La clause LIMIT vient après l’instruction SELECT mais avant les modificateurs (tels que DISTINCT). SELECT LIMIT 5 DISTINCT a, b, c

FROM table

WHERE a > 10

L’extrait de code suivant fournit une implémentation de LimitClause pour un pilote qui attend une clause LIMIT, avec une clause OFFSET facultative, au format suivant : [OFFSET <offset> ROWS] LIMIT <row_count>

LimitClause = (skip, take) =>
    let
        offset = if (skip > 0) then Text.Format("OFFSET #{0} ROWS", {skip}) else "",
        limit = if (take <> null) then Text.Format("LIMIT #{0}", {take}) else ""
    in
        [
            Text = Text.Format("#{0} #{1}", {offset, limit}),
            Location = "AfterQuerySpecification"
        ]

L’extrait de code suivant fournit une implémentation de LimitClause pour un pilote qui prend en charge la clause LIMIT, mais pas la clause OFFSET. Format : LIMIT <row_count>.

LimitClause = (skip, take) =>
    if (skip > 0) then error "Skip/Offset not supported"
    else
    [
        Text = Text.Format("LIMIT #{0}", {take}),
        Location = "AfterQuerySpecification"
    ]

Substitution de SqlCapabilities

Champ Détails
FractionalSecondsScale Valeur numérique comprise entre 1 et 7 indiquant le nombre de décimales prises en charge pour les valeurs de millisecondes. Cette valeur doit être définie par les connecteurs qui souhaitent activer le pliage de requête sur les valeurs de dateheure.

Valeur par défaut : null
PrepareStatements Valeur logique indiquant que des instructions devraient être préparées à l’aide de SQLPrepare.

Valeur par défaut : false
SupportsTop Valeur logique indiquant que le pilote prend en charge la clause TOP pour limiter le nombre de lignes retournées.

Valeur par défaut : false
StringLiteralEscapeCharacters Liste de valeurs de texte qui spécifient le ou les caractères à utiliser lors de l’échappement de littéraux de chaîne et d’expressions LIKE.

Exemple : {""}

Valeur par défaut : null
SupportsDerivedTable Valeur logique indiquant que le pilote prend en charge des tables dérivées (sous-sélections).

Cette valeur est supposée être true pour les pilotes définissant leur niveau de conformité sur SQL_SC_SQL92_FULL (signalé par le pilote ou remplacé par le paramètre Sql92Conformance). Pour tous les autres niveaux de conformité, cette valeur est false par défaut.

Si votre pilote ne signale pas le niveau de conformité SQL_SC_SQL92_FULL, mais prend en charge les tables dérivées, définissez cette valeur sur true.

La prise en charge de tables dérivées est requise pour de nombreux scénarios DirectQuery.
SupportsNumericLiterals Valeur logique indiquant si le SQL généré devrait inclure des valeurs de littéraux numériques. Lorsque la valeur est false, les valeurs numériques sont toujours spécifiées à l’aide d’une liaison de paramètre.

Valeur par défaut : false
SupportsStringLiterals Valeur logique indiquant si le SQL généré devrait inclure des valeurs de littéraux de chaîne. Lorsque la valeur est false, les valeurs de chaîne sont toujours spécifiées à l’aide d’une liaison de paramètre.

Valeur par défaut : false
SupportsOdbcDateLiterals Valeur logique indiquant si le SQL généré devrait inclure des valeurs de littéraux de date. Lorsque la valeur est false, les valeurs de date sont toujours spécifiées à l’aide d’une liaison de paramètre.

Valeur par défaut : false
SupportsOdbcTimeLiterals Valeur logique indiquant si le SQL généré devrait inclure des valeurs de littéraux d’heure. Lorsque la valeur est false, les valeurs d’heure sont toujours spécifiées à l’aide d’une liaison de paramètre.

Valeur par défaut : false
SupportsOdbcTimestampLiterals Valeur logique indiquant si le SQL généré devrait inclure des valeurs de littéraux d’horodateur. Lorsque la valeur est false, les valeurs d’horodateur sont toujours spécifiées à l’aide d’une liaison de paramètre.

Valeur par défaut : false

Substitution de SQLColumns

SQLColumns est un gestionnaire de fonction qui reçoit les résultats d’un appel ODBC à SQLColumns. Le paramètre source contient une table avec les informations de type de données. Cette substitution est généralement utilisée pour corriger les discordances de type de données entre les appels à SQLGetTypeInfo et SQLColumns.

Pour plus d’informations sur le format du paramètre de table source, consultez Fonction SQLColumns.

Substitution de SQLGetFunctions

Ce champ est utilisé pour remplacer les valeurs SQLFunctions retournées par un pilote ODBC. Il contient un enregistrement dans lequel les noms de champs sont identiques aux constantes FunctionId définies pour la fonction ODBC SQLGetFunctions. Des constantes numériques pour chacun de ces champs figurent dans la Spécification ODBC.

Champ Détails
SQL_CONVERT_FUNCTIONS Indique les fonctions prises en charge lors de conversions de type. Par défaut, le moteur M tente d’utiliser la fonction CONVERT. Les pilotes qui préfèrent utiliser la fonction CAST peuvent remplacer cette valeur pour signaler que seul SQL_FN_CVT_CAST (valeur numérique de 0x2) est pris en charge.
SQL_API_SQLBINDCOL Une valeur logique (true/false) qui indique si le moteur mashup devrait utiliser le SQLBindCol API lors de la récupération de données. Quand elle est définie sur false, la fonction SQLGetData est utilisée à la place.

Valeur par défaut : false

L’extrait de code suivant fournit un exemple indiquant explicitement au moteur M d’utiliser la fonction CAST plutôt que la fonction CONVERT.

SQLGetFunctions = [
    SQL_CONVERT_FUNCTIONS = 0x2 /* SQL_FN_CVT_CAST */
]

Substitution de SQLGetInfo

Ce champ est utilisé pour remplacer les valeurs SQLGetInfo retournées par un pilote ODBC. Il contient un enregistrement dans lequel les noms de champs sont identiques aux constantes InfoType définies pour la fonction ODBC SQLGetInfo. Des constantes numériques pour chacun de ces champs figurent dans la Spécification ODBC. La liste complète des InfoTypes qui sont vérifiés figure dans les fichiers de trace du moteur mashup.

Le tableau suivant contient les propriétés de SQLGetInfo couramment remplacées :

Champ Détails
SQL_SQL_CONFORMANCE Valeur entière indiquant le niveau de SQL-92 pris en charge par le pilote :

(1) SQL_SC_SQL92_ENTRY : conforme SQL-92 au niveau d’entrée.
(2) SQL_SC_FIPS127_2_TRANSITIONAL : conforme FIPS 127-2 au niveau de transition.
(4) SQL_SC_ SQL92_INTERMEDIATE » Conforme SQL-92 au niveau intermédiaire.
(8) SQL_SC_SQL92_FULL : conforme SQL-92 au niveau complet.

Dans des scénarios Power Query, le connecteur est utilisé en mode Lecture seule. La plupart des pilotes souhaiteront signaler un niveau de conformité SQL_SC_SQL92_FULL et remplacer un comportement de génération SQL spécifique à l’aide des propriétés SQLGetInfo et SQLGetFunctions.
SQL_SQL92_PREDICATES Masque de bits énumérant les prédicats pris en charge dans une instruction SELECT, comme défini dans SQL-92.

Accédez à Constantes SQL_SP_* dans la spécification ODBC.
SQL_AGGREGATE_FUNCTIONS Masque de bits énumérant la prise en charge des fonctions d’agrégation.

SQL_AF_ALL
SQL_AF_AVG
SQL_AF_COUNT
SQL_AF_DISTINCT
SQL_AF_MAX
SQL_AF_MIN
SQL_AF_SUM

Accédez à Constantes SQL_AF_* dans la spécification ODBC.
SQL_GROUP_BY Valeur entière spécifiant la relation entre les colonnes dans la clause GROUP BY et les colonnes non agrégées dans la liste de sélection :

SQL_GB_COLLATE : une clause COLLATE peut être spécifiée à la fin de chaque colonne de regroupement.

SQL_GB_NOT_SUPPORTED : les clauses GROUP BY ne sont pas prises en charge.

SQL_GB_GROUP_BY_EQUALS_SELECT : la clause GROUP BY doit contenir toutes les colonnes non agrégées dans la liste de sélection. Elle ne peut contenir aucune autre colonne. Par exemple, SELECT DEPT, MAX(SALARY) FROM EMPLOYEE GROUP BY DEPT.

SQL_GB_GROUP_BY_CONTAINS_SELECT : la clause GROUP BY doit contenir toutes les colonnes non agrégées dans la liste de sélection. Elle peut contenir des colonnes qui ne figurent pas dans la liste de sélection. Par exemple, SELECT DEPT, MAX(SALARY) FROM EMPLOYEE GROUP BY DEPT, AGE.

SQL_GB_NO_RELATION : les colonnes dans la clause GROUP BY et la liste de sélection ne sont pas associées. La signification de colonnes non groupées et non agrégées dans la liste de sélection dépend de la source de données. Par exemple, SELECT DEPT, SALARY FROM EMPLOYEE GROUP BY DEPT, AGE.

Accédez à Constantes SQL_GB_* dans la spécification ODBC.

La fonction d’assistance suivante peut être utilisée pour créer des valeurs de masque de bits à partir d’une liste de valeurs entières :

Flags = (flags as list) =>
    let
        Loop = List.Generate(
                  ()=> [i = 0, Combined = 0],
                  each [i] < List.Count(flags),
                  each [i = [i]+1, Combined =*Number.BitwiseOr([Combined], flags{i})],
                  each [Combined]),
        Result = List.Last(Loop, 0)
    in
        Result;

Substitution de SQLGetTypeInfo

La fonction SQLGetTypeInfo peut être spécifiée de deux façons :

  • Valeur table fixe contenant les mêmes informations de type qu’un appel ODBC à SQLGetTypeInfo.
  • Fonction qui accepte un argument de table et retourne une table. L’argument contient les résultats d’origine de l’appel ODBC à SQLGetTypeInfo. L’implémentation de votre fonction peut modifier ou ajouter à cette table.

La première approche est utilisée pour remplacer complètement les valeurs retournées par le pilote ODBC. La deuxième approche est utilisée si vous souhaitez ajouter ou modifier ces valeurs.

Pour plus d’informations sur le format du paramètre de table de types et la valeur de retour attendue, consultez la référence de la fonction SQLGetTypeInfo.

SQLGetTypeInfo utilisant une table statique

L’extrait de code suivant fournit une implémentation statique pour SQLGetTypeInfo.

SQLGetTypeInfo = #table(
    { "TYPE_NAME",      "DATA_TYPE", "COLUMN_SIZE", "LITERAL_PREF", "LITERAL_SUFFIX", "CREATE_PARAS",           "NULLABLE", "CASE_SENSITIVE", "SEARCHABLE", "UNSIGNED_ATTRIBUTE", "FIXED_PREC_SCALE", "AUTO_UNIQUE_VALUE", "LOCAL_TYPE_NAME", "MINIMUM_SCALE", "MAXIMUM_SCALE", "SQL_DATA_TYPE", "SQL_DATETIME_SUB", "NUM_PREC_RADIX", "INTERNAL_PRECISION", "USER_DATA_TYPE" }, {

    { "char",           1,          65535,          "'",            "'",              "max. length",            1,          1,                3,            null,                 0,                  null,                "char",            null,            null,            -8,              null,               null,             0,                    0                }, 
    { "int8",           -5,         19,             "'",            "'",              null,                     1,          0,                2,            0,                    10,                 0,                   "int8",            0,               0,               -5,              null,               2,                0,                    0                },
    { "bit",            -7,         1,              "'",            "'",              null,                     1,          1,                3,            null,                 0,                  null,                "bit",             null,            null,            -7,              null,               null,             0,                    0                },
    { "bool",           -7,         1,              "'",            "'",              null,                     1,          1,                3,            null,                 0,                  null,                "bit",             null,            null,            -7,              null,               null,             0,                    0                },
    { "date",           9,          10,             "'",            "'",              null,                     1,          0,                2,            null,                 0,                  null,                "date",            null,            null,            9,               1,                  null,             0,                    0                }, 
    { "numeric",        3,          28,             null,           null,             null,                     1,          0,                2,            0,                    0,                   0,                  "numeric",         0,               0,               2,               null,               10,               0,                    0                },
    { "float8",         8,          15,             null,           null,             null,                     1,          0,                2,            0,                    0,                   0,                  "float8",          null,            null,            6,               null,               2,                0,                    0                },
    { "float8",         6,          17,             null,           null,             null,                     1,          0,                2,            0,                    0,                   0,                  "float8",          null,            null,            6,               null,               2,                0,                    0                },
    { "uuid",           -11,        37,             null,           null,             null,                     1,          0,                2,            null,                 0,                  null,                "uuid",            null,            null,            -11,             null,               null,             0,                    0                },
    { "int4",           4,          10,             null,           null,             null,                     1,          0,                2,            0,                    0,                   0,                  "int4",            0,               0,               4,               null,               2,                0,                    0                },
    { "text",           -1,         65535,          "'",            "'",              null,                     1,          1,                3,            null,                 0,                  null,                "text",            null,            null,            -10,             null,               null,             0,                    0                },
    { "lo",             -4,         255,            "'",            "'",              null,                     1,          0,                2,            null,                 0,                  null,                "lo",              null,            null,            -4,              null,               null,             0,                    0                }, 
    { "numeric",        2,          28,             null,           null,             "precision, scale",       1,          0,                2,            0,                    10,                 0,                   "numeric",         0,               6,               2,               null,               10,               0,                    0                },
    { "float4",         7,          9,              null,           null,             null,                     1,          0,                2,            0,                    10,                 0,                   "float4",          null,            null,            7,               null,               2,                0,                    0                }, 
    { "int2",           5,          19,             null,           null,             null,                     1,          0,                2,            0,                    10,                 0,                   "int2",            0,               0,               5,               null,               2,                0,                    0                }, 
    { "int2",           -6,         5,              null,           null,             null,                     1,          0,                2,            0,                    10,                 0,                   "int2",            0,               0,               5,               null,               2,                0,                    0                }, 
    { "timestamp",      11,         26,             "'",            "'",              null,                     1,          0,                2,            null,                 0,                  null,                "timestamp",       0,               38,              9,               3,                  null,             0,                    0                }, 
    { "date",           91,         10,             "'",            "'",              null,                     1,          0,                2,            null,                 0,                  null,                "date",            null,            null,            9,               1,                  null,             0,                    0                }, 
    { "timestamp",      93,         26,             "'",            "'",              null,                     1,          0,                2,            null,                 0,                  null,                "timestamp",       0,               38,              9,               3,                  null,             0,                    0                }, 
    { "bytea",          -3,         255,            "'",            "'",              null,                     1,          0,                2,            null,                 0,                  null,                "bytea",           null,            null,            -3,              null,               null,             0,                    0                }, 
    { "varchar",        12,         65535,          "'",            "'",              "max. length",            1,          0,                2,            null,                 0,                  null,                "varchar",         null,            null,           -9,               null,               null,             0,                    0                }, 
    { "char",           -8,         65535,          "'",            "'",              "max. length",            1,          1,                3,            null,                 0,                  null,                "char",            null,            null,           -8,               null,               null,             0,                    0                }, 
    { "text",           -10,        65535,          "'",            "'",              "max. length",            1,          1,                3,            null,                 0,                  null,                "text",            null,            null,           -10,              null,               null,             0,                    0                }, 
    { "varchar",        -9,         65535,          "'",            "'",              "max. length",            1,          1,                3,            null,                 0,                  null,                "varchar",         null,            null,           -9,               null,               null,             0,                    0                },
    { "bpchar",         -8,         65535,           "'",            "'",              "max. length",            1,          1,                3,            null,                 0,                  null,                "bpchar",          null,            null,            -9,               null,               null,            0,                    0                } }
);

SQLGetTypeInfo utilisant une fonction

Les extraits de code suivants ajoutent le type bpchar aux types existants retournés par le pilote.

SQLGetTypeInfo = (types as table) as table =>
   let
       newTypes = #table(
           {
               "TYPE_NAME",
               "DATA_TYPE",
               "COLUMN_SIZE",
               "LITERAL_PREF",
               "LITERAL_SUFFIX",
               "CREATE_PARAS",
               "NULLABLE",
               "CASE_SENSITIVE",
               "SEARCHABLE",
               "UNSIGNED_ATTRIBUTE",
               "FIXED_PREC_SCALE",
               "AUTO_UNIQUE_VALUE",
               "LOCAL_TYPE_NAME",
               "MINIMUM_SCALE",
               "MAXIMUM_SCALE",
               "SQL_DATA_TYPE",
               "SQL_DATETIME_SUB",
               "NUM_PREC_RADIX",
               "INTERNAL_PRECISION",
               "USER_DATA_TYPE"
            },
            // we add a new entry for each type we want to add
            {
                {
                    "bpchar",
                    -8,
                    65535,
                    "'",
                    "'",
                    "max. length",
                    1,
                    1,
                    3,
                    null,
                    0,
                    null,
                    "bpchar",
                    null,
                    null,
                    -9,
                    null,
                    null,
                    0,
                    0
                }
            }),
        append = Table.Combine({types, newTypes})
    in
        append;

Définition de la chaîne de connexion

La chaîne de connexion pour votre pilote ODBC est définie à l’aide du premier argument des fonctions Odbc.DataSource et Odbc.Query. La valeur peut être du texte ou un enregistrement M. Lors de l’utilisation de l’enregistrement, chaque champ dans celui-ci deviendra une propriété dans la chaîne de connexion. Toutes les chaînes de connexion nécessitent un champ Driver (ou un champ DSN si vous avez besoin que les utilisateurs préconfigurent un nom de source de données au niveau du système). Les propriétés liées aux informations d’identification sont définies séparément. D’autres propriétés sont spécifiques du pilote.

L’extrait de code ci-dessous montre la définition d’une nouvelle fonction de source de données, la création de l’enregistrement ConnectionString et l’appel de la fonction Odbc.DataSource.

[DataSource.Kind="SqlODBC", Publish="SqlODBC.Publish"]
shared SqlODBC.Contents = (server as text) =>
    let
        ConnectionString = [
            Driver = "SQL Server Native Client 11.0",
            Server = server,
            MultiSubnetFailover = "Yes",
            ApplicationIntent = "ReadOnly",
            APP = "PowerBICustomConnector"
        ],
        OdbcDatasource = Odbc.DataSource(ConnectionString)
    in
        OdbcDatasource;

Étapes suivantes