Liaison d’entrée Azure SQL pour Azure Functions

Quand une fonction s’exécute, la liaison d’entrée Azure SQL récupère les données d’une base de données et les passe au paramètre d’entrée de la fonction.

Pour plus d’informations sur les détails d’installation et de configuration, consultez la vue d’ensemble.

Important

Cet article utilise des onglets pour prendre en charge plusieurs versions du modèle de programmation Node.js. Le modèle v4 est en disponibilité générale. Il est conçu pour offrir une expérience plus flexible et intuitive aux développeurs JavaScript et TypeScript. Pour plus d’informations sur le fonctionnement du modèle v4, reportez-vous au guide du développeur Azure Functions Node.js. Si vous souhaitez obtenir plus d’informations sur les différences entre v3 et v4, consultez le guide de migration.

Exemples

Une fonction C# peut être créée à l’aide de l’un des modes C# suivants :

• Modèle worker isolé : fonction C# compilée exécutée dans un processus worker isolé du runtime. Le processus Worker isolé est requis pour prendre en charge les fonctions C# exécutées sur les versions LTS et non-LTS de .NET et de .NET Framework.
• Modèle In-process : fonction C# compilée exécutée dans le même processus que le runtime Functions.
• Script C# : principalement utilisé lors de la création de fonctions C# dans le portail Azure.

Important

Le support prendra fin pour le modèle in-process le 10 novembre 2026. Nous vous recommandons vivement de migrer vos applications vers le modèle worker isolé pour une prise en charge complète.

Modèle de worker isolé

D’autres exemples pour la liaison d’entrée Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

• Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête
• Déclencheur HTTP, obtention de plusieurs lignes à partir de données d’itinéraire
• Déclencheur HTTP, supprimer les lignes

Les exemples font référence à une classe ToDoItem et à une table de base de données correspondante :

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête

L’exemple suivant illustre une fonction C# qui récupère un dossier unique. La fonction est déclenchée par une requête HTTP qui utilise une chaîne de requête pour spécifier l’ID. Cet ID est utilisé pour récupérer un ToDoItemenregistrement avec la requête spécifiée.

Notes

Le paramètre de chaîne de requête HTTP respecte la casse.

using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItem
    {
        [FunctionName("GetToDoItem")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitem")]
            HttpRequest req,
            [SqlInput(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
                commandType: System.Data.CommandType.Text,
                parameters: "@Id={Query.id}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItem)
        {
            return new OkObjectResult(toDoItem.FirstOrDefault());
        }
    }
}

Déclencheur HTTP, obtention de plusieurs lignes à partir du paramètre d’itinéraire

L’exemple suivant illustre une fonction C# qui récupère les documents retournés par la requête. La fonction est déclenchée par une requête HTTP qui utilise des données de routage pour spécifier la valeur d’un paramètre de requête. Ce paramètre est utilisé pour filtrer les enregistrements ToDoItem dans la requête spécifiée.

using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItems
    {
        [FunctionName("GetToDoItems")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitems/{priority}")]
            HttpRequest req,
            [SqlInput(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where [Priority] > @Priority",
                commandType: System.Data.CommandType.Text,
                parameters: "@Priority={priority}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

déclencheur HTTP, supprimer les lignes

L’exemple suivant montre une fonction C# qui exécute une procédure stockée avec une entrée à partir du paramètre de requête de requête HTTP.

La procédure stockée dbo.DeleteToDo doit être créée sur la base de données SQL. Dans cet exemple, la procédure stockée supprime un enregistrement unique ou tous les enregistrements en fonction de la valeur du paramètre.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

namespace AzureSQL.ToDo
{
    public static class DeleteToDo
    {
        // delete all items or a specific item from querystring
        // returns remaining items
        // uses input binding with a stored procedure DeleteToDo to delete items and return remaining items
        [FunctionName("DeleteToDo")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "DeleteFunction")] HttpRequest req,
            ILogger log,
            [SqlInput(commandText: "DeleteToDo", commandType: System.Data.CommandType.StoredProcedure, 
                parameters: "@Id={Query.id}", connectionStringSetting: "SqlConnectionString")] 
                IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

Modèle in-process

D’autres exemples pour la liaison d’entrée Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

• Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête
• Déclencheur HTTP, obtention de plusieurs lignes à partir de données d’itinéraire
• Déclencheur HTTP, supprimer les lignes

Les exemples font référence à une classe ToDoItem et à une table de base de données correspondante :

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête

L’exemple suivant illustre une fonction C# qui récupère un dossier unique. La fonction est déclenchée par une requête HTTP qui utilise une chaîne de requête pour spécifier l’ID. Cet ID est utilisé pour récupérer un ToDoItemenregistrement avec la requête spécifiée.

Notes

Le paramètre de chaîne de requête HTTP respecte la casse.

using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItem
    {
        [FunctionName("GetToDoItem")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitem")]
            HttpRequest req,
            [Sql(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
                commandType: System.Data.CommandType.Text,
                parameters: "@Id={Query.id}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItem)
        {
            return new OkObjectResult(toDoItem.FirstOrDefault());
        }
    }
}

Déclencheur HTTP, obtention de plusieurs lignes à partir du paramètre d’itinéraire

L’exemple suivant illustre une fonction C# qui récupère les documents retournés par la requête. La fonction est déclenchée par une requête HTTP qui utilise des données de routage pour spécifier la valeur d’un paramètre de requête. Ce paramètre est utilisé pour filtrer les enregistrements ToDoItem dans la requête spécifiée.

using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItems
    {
        [FunctionName("GetToDoItems")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitems/{priority}")]
            HttpRequest req,
            [Sql(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where [Priority] > @Priority",
                commandType: System.Data.CommandType.Text,
                parameters: "@Priority={priority}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

déclencheur HTTP, supprimer les lignes

L’exemple suivant montre une fonction C# qui exécute une procédure stockée avec une entrée à partir du paramètre de requête de requête HTTP.

La procédure stockée dbo.DeleteToDo doit être créée sur la base de données SQL. Dans cet exemple, la procédure stockée supprime un enregistrement unique ou tous les enregistrements en fonction de la valeur du paramètre.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace AzureSQL.ToDo
{
    public static class DeleteToDo
    {
        // delete all items or a specific item from querystring
        // returns remaining items
        // uses input binding with a stored procedure DeleteToDo to delete items and return remaining items
        [FunctionName("DeleteToDo")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "DeleteFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "DeleteToDo", commandType: System.Data.CommandType.StoredProcedure, 
                parameters: "@Id={Query.id}", connectionStringSetting: "SqlConnectionString")] 
                IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

D’autres exemples pour la liaison d’entrée Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

• Déclencheur HTTP, obtenir plusieurs lignes
• Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête
• Déclencheur HTTP, supprimer les lignes

Les exemples font référence à une classe ToDoItem (dans un fichier distinct ToDoItem.java) et à une table de base de données correspondante :

package com.function;
import java.util.UUID;

public class ToDoItem {
    public UUID Id;
    public int order;
    public String title;
    public String url;
    public boolean completed;

    public ToDoItem() {
    }

    public ToDoItem(UUID Id, int order, String title, String url, boolean completed) {
        this.Id = Id;
        this.order = order;
        this.title = title;
        this.url = url;
        this.completed = completed;
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, obtenir plusieurs lignes

L’exemple suivant montre une liaison d’entrée SQL dans une fonction Java déclenchée par une requête HTTP et lit à partir d’une requête et retourne les résultats dans la réponse HTTP.

package com.function;

import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.microsoft.azure.functions.sql.annotation.SQLInput;

import java.util.Optional;

public class GetToDoItems {
    @FunctionName("GetToDoItems")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            @SQLInput(
                name = "toDoItems",
                commandText = "SELECT * FROM dbo.ToDo",
                commandType = "Text",
                connectionStringSetting = "SqlConnectionString")
                ToDoItem[] toDoItems) {
        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(toDoItems).build();
    }
}

Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête

L’exemple suivant montre une liaison d’entrée SQL dans une fonction Java qui est déclenchée par une requête HTTP et lit à partir d’une requête filtrée par un paramètre de la chaîne de requête et retourne la ligne dans la réponse HTTP.

public class GetToDoItem {
    @FunctionName("GetToDoItem")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            @SQLInput(
                name = "toDoItems",
                commandText = "SELECT * FROM dbo.ToDo",
                commandType = "Text",
                parameters = "@Id={Query.id}",
                connectionStringSetting = "SqlConnectionString")
                ToDoItem[] toDoItems) {
        ToDoItem toDoItem = toDoItems[0];
        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(toDoItem).build();
    }
}

déclencheur HTTP, supprimer les lignes

L’exemple suivant montre une liaison d’entrée SQL dans une fonction Java déclenchée par une requête HTTP et exécute une procédure stockée avec une entrée à partir du paramètre de requête de requête HTTP.

La procédure stockée dbo.DeleteToDo doit être créée sur la base de données. Dans cet exemple, la procédure stockée supprime un enregistrement unique ou tous les enregistrements en fonction de la valeur du paramètre.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

public class DeleteToDo {
    @FunctionName("DeleteToDo")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            @SQLInput(
                name = "toDoItems",
                commandText = "dbo.DeleteToDo",
                commandType = "StoredProcedure",
                parameters = "@Id={Query.id}",
                connectionStringSetting = "SqlConnectionString")
                ToDoItem[] toDoItems) {
        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(toDoItems).build();
    }
}

D’autres exemples pour la liaison d’entrée Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

• Déclencheur HTTP, obtenir plusieurs lignes
• Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête
• Déclencheur HTTP, supprimer les lignes

Les exemples font référence à une table de base de données :

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, obtenir plusieurs lignes

L’exemple suivant montre une liaison d’entrée SQL déclenchée par une requête HTTP et lit à partir d’une requête et retourne les résultats dans la réponse HTTP.

Modèle v4

import { app, HttpRequest, HttpResponseInit, input, InvocationContext } from '@azure/functions';

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo',
    commandType: 'Text',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL input binding function processed a request.');
    const toDoItems = context.extraInputs.get(sqlInput);
    return {
        jsonBody: toDoItems,
    };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: httpTrigger1,
});

Modèle v3

Les exemples TypeScript ne sont pas documentés pour le modèle v3.

Modèle v4

const { app, input } = require('@azure/functions');

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo',
    commandType: 'Text',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: (request, context) => {
        context.log('HTTP trigger and SQL input binding function processed a request.');
        const toDoItems = context.extraInputs.get(sqlInput);
        return {
            jsonBody: toDoItems,
        };
    },
});

Modèle v3

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo",
    "commandType": "Text",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code JavaScript :

module.exports = async function (context, req, todoItems) {
    context.log('JavaScript HTTP trigger and SQL input binding function processed a request.');

    context.res = {
        // status: 200, /* Defaults to 200 */
        mimetype: "application/json",
        body: todoItems
    };
}

Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête

L’exemple suivant montre une liaison d’entrée SQL déclenchée par une requête HTTP et lue à partir d’une requête filtrée par un paramètre de la chaîne de requête et retourne la ligne dans la réponse HTTP.

Modèle v4

import { app, HttpRequest, HttpResponseInit, input, InvocationContext } from '@azure/functions';

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id',
    commandType: 'Text',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL input binding function processed a request.');
    const toDoItem = context.extraInputs.get(sqlInput);
    return {
        jsonBody: toDoItem,
    };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: httpTrigger1,
});

Modèle v3

Les exemples TypeScript ne sont pas documentés pour le modèle v3.

Modèle v4

const { app, input } = require('@azure/functions');

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id',
    commandType: 'Text',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: (request, context) => {
        context.log('HTTP trigger and SQL input binding function processed a request.');
        const toDoItem = context.extraInputs.get(sqlInput);
        return {
            jsonBody: toDoItem,
        };
    },
});

Modèle v3

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code JavaScript :

module.exports = async function (context, req, todoItem) {
    context.log('JavaScript HTTP trigger and SQL input binding function processed a request.');

    context.res = {
        // status: 200, /* Defaults to 200 */
        mimetype: "application/json",
        body: todoItem
    };
}

déclencheur HTTP, supprimer les lignes

L’exemple suivant montre une liaison d’entrée SQL déclenchée par une requête HTTP et exécute une procédure stockée avec une entrée à partir du paramètre de requête de requête HTTP.

La procédure stockée dbo.DeleteToDo doit être créée sur la base de données. Dans cet exemple, la procédure stockée supprime un enregistrement unique ou tous les enregistrements en fonction de la valeur du paramètre.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

Modèle v4

import { app, HttpRequest, HttpResponseInit, input, InvocationContext } from '@azure/functions';

const sqlInput = input.sql({
    commandText: 'DeleteToDo',
    commandType: 'StoredProcedure',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL input binding function processed a request.');
    const toDoItems = context.extraInputs.get(sqlInput);
    return {
        jsonBody: toDoItems,
    };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: httpTrigger1,
});

Modèle v3

Les exemples TypeScript ne sont pas documentés pour le modèle v3.

Modèle v4

const { app, input } = require('@azure/functions');

const sqlInput = input.sql({
    commandText: 'DeleteToDo',
    commandType: 'StoredProcedure',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: (request, context) => {
        context.log('HTTP trigger and SQL input binding function processed a request.');
        const toDoItems = context.extraInputs.get(sqlInput);
        return {
            jsonBody: toDoItems,
        };
    },
});

Modèle v3

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code JavaScript :

module.exports = async function (context, req, todoItems) {
    context.log('JavaScript HTTP trigger and SQL input binding function processed a request.');

    context.res = {
        // status: 200, /* Defaults to 200 */
        mimetype: "application/json",
        body: todoItems
    };
}

D’autres exemples pour la liaison d’entrée Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

• Déclencheur HTTP, obtenir plusieurs lignes
• Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête
• Déclencheur HTTP, supprimer les lignes

Les exemples font référence à une table de base de données :

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, obtenir plusieurs lignes

L’exemple suivant montre une liaison d’entrée SQL dans un fichier function.json et une fonction PowerShell déclenchée par une requête HTTP et lit à partir d’une requête et retourne les résultats dans la réponse HTTP.

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo",
    "commandType": "Text",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code PowerShell pour la fonction dans le fichier run.ps1 :

using namespace System.Net

param($Request, $todoItems)

Write-Host "PowerShell function with SQL Input Binding processed a request."

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [System.Net.HttpStatusCode]::OK
    Body = $todoItems
})

Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête

L’exemple suivant montre une liaison d’entrée SQL dans une fonction PowerShell déclenchée par une requête HTTP et lit à partir d’une requête filtrée par un paramètre de la chaîne de requête et retourne la ligne dans la réponse HTTP.

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code PowerShell pour la fonction dans le fichier run.ps1 :

using namespace System.Net

param($Request, $todoItem)

Write-Host "PowerShell function with SQL Input Binding processed a request."

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [System.Net.HttpStatusCode]::OK
    Body = $todoItem
})

déclencheur HTTP, supprimer les lignes

L’exemple suivant montre une liaison d’entrée SQL dans un fichier function.json et une fonction PowerShell déclenchée par une requête HTTP et exécute une procédure stockée avec une entrée à partir du paramètre de requête de requête HTTP.

La procédure stockée dbo.DeleteToDo doit être créée sur la base de données. Dans cet exemple, la procédure stockée supprime un enregistrement unique ou tous les enregistrements en fonction de la valeur du paramètre.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code PowerShell pour la fonction dans le fichier run.ps1 :

using namespace System.Net

param($Request, $todoItems)

Write-Host "PowerShell function with SQL Input Binding processed a request."

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [System.Net.HttpStatusCode]::OK
    Body = $todoItems
})

D’autres exemples pour la liaison d’entrée Azure SQL sont disponibles dans le dépôt GitHub.

Cette section contient les exemples suivants :

• Déclencheur HTTP, obtenir plusieurs lignes
• Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête
• Déclencheur HTTP, supprimer les lignes

Les exemples font référence à une table de base de données :

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Déclencheur HTTP, obtenir plusieurs lignes

L’exemple suivant montre une liaison d’entrée SQL dans un fichier function.json et une fonction Python déclenchée par une requête HTTP et lit à partir d’une requête et retourne les résultats dans la réponse HTTP.

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo",
    "commandType": "Text",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code Python :

import azure.functions as func
import json

def main(req: func.HttpRequest, todoItems: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todoItems))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    ) 

Déclencheur HTTP, obtenir une ligne par ID à partir de la chaîne de requête

L’exemple suivant montre une liaison d’entrée SQL dans une fonction Python qui est déclenchée par une requête HTTP et lit à partir d’une requête filtrée par un paramètre de la chaîne de requête et retourne la ligne dans la réponse HTTP.

L’exemple suivant montre une liaison de données dans le fichier function.json :

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code Python :

import azure.functions as func
import json

def main(req: func.HttpRequest, todoItem: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todoItem))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    ) 

déclencheur HTTP, supprimer les lignes

L’exemple suivant montre une liaison d’entrée SQL dans un fichier function.json et une fonction Python déclenchée par une requête HTTP et exécute une procédure stockée avec une entrée à partir du paramètre de requête de requête HTTP.

La procédure stockée dbo.DeleteToDo doit être créée sur la base de données. Dans cet exemple, la procédure stockée supprime un enregistrement unique ou tous les enregistrements en fonction de la valeur du paramètre.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

La section configuration décrit ces propriétés.

Voici un exemple de code Python :

import azure.functions as func
import json

def main(req: func.HttpRequest, todoItems: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todoItems))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    ) 

Attributs

La bibliothèque C# utilise l’attribut SqlAttribute pour déclarer les liaisons SQL sur la fonction, qui a les propriétés suivantes :

Propriété d’attribut	Description
CommandText	Obligatoire. Commande de requête Transact-SQL ou nom de la procédure stockée exécutée par la liaison.
ConnectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données sur laquelle la requête ou la procédure stockée est exécutée. Cette valeur n’est pas la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en un nom de variable d’environnement.
CommandType	Obligatoire. Valeur CommandType, qui est Text pour une requête et StoredProcedure pour une procédure stockée.
Paramètres	facultatif. Zéro ou plusieurs valeurs de paramètre passées à la commande lors de l’exécution, sous la forme d’une seule chaîne. Doit respecter le format @param1=param1,@param2=param2. Ni le nom du paramètre ni la valeur du paramètre ne peuvent contenir une virgule (,) ou un signe égal (=).

Annotations

Dans la bibliothèque du runtime des fonctions Java, utilisez l’annotation @SQLInput (com.microsoft.azure.functions.sql.annotation.SQLInput) sur les paramètres dont la valeur proviendrait d’Azure SQL. Cette annotation prend en charge les éléments suivants :

Élément	Description
commandText	Obligatoire. Commande de requête Transact-SQL ou nom de la procédure stockée exécutée par la liaison.
connectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données sur laquelle la requête ou la procédure stockée est exécutée. Cette valeur n’est pas la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en un nom de variable d’environnement.
commandType	Obligatoire. Valeur CommandType, qui est Text pour une requête et StoredProcedure pour une procédure stockée.
name	Obligatoire. Nom unique de la liaison de fonction.
parameters	facultatif. Zéro ou plusieurs valeurs de paramètre passées à la commande lors de l’exécution, sous la forme d’une seule chaîne. Doit respecter le format @param1=param1,@param2=param2. Ni le nom du paramètre ni la valeur du paramètre ne peuvent contenir une virgule (,) ou un signe égal (=).

Configuration

Modèle v4

Le tableau suivant explique les propriétés que vous pouvez définir pour l’objet options passé à la méthode input.sql().

Propriété	Description
commandText	Obligatoire. Commande de requête Transact-SQL ou nom de la procédure stockée exécutée par la liaison.
connectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données sur laquelle la requête ou la procédure stockée est exécutée. Cette valeur n’est pas la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en un nom de variable d’environnement. Les mots clés facultatifs dans la valeur de chaîne de connexion sont disponibles pour affiner la connectivité des liaisons SQL.
commandType	Obligatoire. Valeur CommandType, qui est Text pour une requête et StoredProcedure pour une procédure stockée.
parameters	facultatif. Zéro ou plusieurs valeurs de paramètre passées à la commande lors de l’exécution, sous la forme d’une seule chaîne. Doit respecter le format @param1=param1,@param2=param2. Ni le nom du paramètre ni la valeur du paramètre ne peuvent contenir une virgule (,) ou un signe égal (=).

Modèle v3

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Propriété	Description
type	Obligatoire. Cette propriété doit être définie sur sql.
direction	Obligatoire. Cette propriété doit être définie sur in.
name	Obligatoire. Nom de la variable qui représente les résultats de la requête dans le code de la fonction.
commandText	Obligatoire. Commande de requête Transact-SQL ou nom de la procédure stockée exécutée par la liaison.
connectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données sur laquelle la requête ou la procédure stockée est exécutée. Cette valeur n’est pas la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en un nom de variable d’environnement. Les mots clés facultatifs dans la valeur de chaîne de connexion sont disponibles pour affiner la connectivité des liaisons SQL.
commandType	Obligatoire. Valeur CommandType, qui est Text pour une requête et StoredProcedure pour une procédure stockée.
parameters	facultatif. Zéro ou plusieurs valeurs de paramètre passées à la commande lors de l’exécution, sous la forme d’une seule chaîne. Doit respecter le format @param1=param1,@param2=param2. Ni le nom du paramètre ni la valeur du paramètre ne peuvent contenir une virgule (,) ou un signe égal (=).

Configuration

Le tableau suivant décrit les propriétés de configuration de liaison que vous définissez dans le fichier function.json.

Propriété function.json	Description
type	Obligatoire. Cette propriété doit être définie sur sql.
direction	Obligatoire. Cette propriété doit être définie sur in.
name	Obligatoire. Nom de la variable qui représente les résultats de la requête dans le code de la fonction.
commandText	Obligatoire. Commande de requête Transact-SQL ou nom de la procédure stockée exécutée par la liaison.
connectionStringSetting	Obligatoire. Nom d’un paramètre d’application qui contient la chaîne de connexion de la base de données sur laquelle la requête ou la procédure stockée est exécutée. Cette valeur n’est pas la chaîne de connexion réelle ; au lieu de cela, elle doit être résolue en un nom de variable d’environnement. Les mots clés facultatifs dans la valeur de chaîne de connexion sont disponibles pour affiner la connectivité des liaisons SQL.
commandType	Obligatoire. Valeur CommandType, qui est Text pour une requête et StoredProcedure pour une procédure stockée.
parameters	facultatif. Zéro ou plusieurs valeurs de paramètre passées à la commande lors de l’exécution, sous la forme d’une seule chaîne. Doit respecter le format @param1=param1,@param2=param2. Ni le nom du paramètre ni la valeur du paramètre ne peuvent contenir une virgule (,) ou un signe égal (=).

Lorsque vous développez en local, ajoutez vos paramètres d’application dans le fichier local.settings.json de la collection Values.

Utilisation

Le constructeur de l'attribut prend le texte de la commande SQL, le type de commande, les paramètres et le nom du paramètre de la chaîne de connexion. La commande peut être une requête Transact-SQL (T-SQL) avec le type de commande System.Data.CommandType.Text ou le nom de la procédure stockée avec le type de commande System.Data.CommandType.StoredProcedure. Le nom du paramètre de la chaîne de connexion correspond au paramètre d’application (dans local.settings.json pour le développement local) qui contient la chaîne de connexion à l’instance SQL ou Azure SQL.

Les requêtes exécutées par la liaison d’entrée sont paramétrées dans Microsoft.Data.SqlClient pour réduire le risque d’injection de code SQL à partir des valeurs de paramètre passées dans la liaison.

Si une exception survient lorsqu’une liaison d’entrée SQL est exécutée, le code de fonction ne s’exécute pas. Cela peut entraîner le retour d’un code d’erreur, comme un déclencheur HTTP retournant un code d’erreur 500.

Étapes suivantes

• Enregistrer des données dans une base de données (liaison de sortie)
• Exécuter une fonction lorsque des données sont modifiées dans une table SQL (déclencheur)
• Exécuter une fonction à partir d’une requête HTTP (déclencheur)
• Examiner l’exemple d’API ToDo avec les liaisons de SQL Azure