Associação de entrada do SQL do Azure para o Azure Functions

Quando uma função é executada, a associação de entrada do SQL do Azure recupera dados de um banco e os transmite para o parâmetro de entrada dessa função.

Para obter informações sobre a instalação e detalhes de configuração, confira a visão geral.

Importante

Este artigo usa guias para dar suporte a várias versões do modelo de programação Node.js. O modelo v4 normalmente está disponível e foi projetado para oferecer uma experiência mais flexível e intuitiva para desenvolvedores de JavaScript e TypeScript. Para obter mais detalhes sobre como funciona o modelo v4, consulte o Guia do desenvolvedor do Node.js para o Azure Functions. Para conhecer as diferenças entre a v3 e a v4, consulte o Guia de migração.

Exemplos

A função C# pode ser criada por meio de um dos seguintes modos C#:

• Modelo de trabalho isolado: função C# compilada executada em um processo de trabalho que está isolado do runtime. É necessário um processo de trabalho isolado para dar suporte às funções C# executadas nas versões LTS e não LTS do .NET e do .NET Framework.
• Modelo em processo: função C# compilada no mesmo processo que o runtime do Functions.
• Script C#: usado principalmente ao criar funções C# no portal do Azure.

Importante

O suporte terminará para o modelo em processo em 10 de novembro de 2026. É altamente recomendável migrar seus aplicativos para o modelo de trabalho isolado para obter suporte completo.

Modelo de trabalho isolado

Mais exemplos para a associação de entrada do SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta
• Gatilho HTTP, obter várias linhas dos dados da rota
• Gatilho HTTP, excluir linhas

Os exemplos se referem a uma classe ToDoItem e a uma tabela de banco de dados correspondente:

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
);

Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta

O exemplo a seguir mostra uma função C# que recupera um único registro. A função é disparada por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID. Essa ID é usada para recuperar um ToDoItem registro com a consulta especificada.

Observação

O parâmetro de cadeia de caracteres de consulta HTTP diferencia maiusculas de minúsculas.

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());
        }
    }
}

Gatilho HTTP, obter várias linhas do parâmetro da rota

O exemplo a seguir mostra uma função C# que recupera documentos retornados pela consulta. A função é disparada por uma solicitação HTTP que usa dados de rota para especificar o valor de um parâmetro de consulta. Esse parâmetro é usado para filtrar os ToDoItem registros na consulta especificada.

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);
        }
    }
}

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma função C# que executa um procedimento armazenado com uma entrada do parâmetro de consulta de solicitação HTTP.

O procedimento armazenado dbo.DeleteToDo deve ser criado no banco de dados SQL. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

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);
        }
    }
}

Modelo em processo

Mais exemplos para a associação de entrada do SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta
• Gatilho HTTP, obter várias linhas dos dados da rota
• Gatilho HTTP, excluir linhas

Os exemplos se referem a uma classe ToDoItem e a uma tabela de banco de dados correspondente:

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
);

Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta

O exemplo a seguir mostra uma função C# que recupera um único registro. A função é disparada por uma solicitação HTTP que usa uma cadeia de caracteres de consulta para especificar a ID. Essa ID é usada para recuperar um ToDoItem registro com a consulta especificada.

Observação

O parâmetro de cadeia de caracteres de consulta HTTP diferencia maiusculas de minúsculas.

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());
        }
    }
}

Gatilho HTTP, obter várias linhas do parâmetro da rota

O exemplo a seguir mostra uma função C# que recupera documentos retornados pela consulta. A função é disparada por uma solicitação HTTP que usa dados de rota para especificar o valor de um parâmetro de consulta. Esse parâmetro é usado para filtrar os ToDoItem registros na consulta especificada.

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);
        }
    }
}

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma função C# que executa um procedimento armazenado com uma entrada do parâmetro de consulta de solicitação HTTP.

O procedimento armazenado dbo.DeleteToDo deve ser criado no banco de dados SQL. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

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);
        }
    }
}

Mais exemplos para a associação de entrada do SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, obter várias linhas
• Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta
• Gatilho HTTP, excluir linhas

Os exemplos se referem a uma classe ToDoItem (em um arquivo ToDoItem.java separado) e a uma tabela de banco de dados correspondente:

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
);

Gatilho HTTP, obter várias linhas

O exemplo a seguir mostra uma ligação de entrada SQL em uma função Java que é acionada por uma solicitação HTTP e lê de uma consulta e retorna os resultados na resposta 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();
    }
}

Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta

O exemplo a seguir mostra uma ligação de entrada SQL em uma função Java que é acionada por uma solicitação HTTP e lê de uma consulta filtrada por um parâmetro da sequência de consulta e retorna a linha na resposta 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();
    }
}

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma ligação de entrada SQL em uma função Java que é acionada por uma solicitação HTTP e executa um procedimento armazenado com entrada do parâmetro de consulta de solicitação HTTP.

O procedimento armazenado dbo.DeleteToDo deve ser criado no banco de dados. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

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();
    }
}

Mais exemplos para a associação de entrada do SQL do Azure estão disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, obter várias linhas
• Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta
• Gatilho HTTP, excluir linhas

Os exemplos se referem a uma tabela de banco de dados:

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
);

Gatilho HTTP, obter várias linhas

O exemplo a seguir mostra uma associação de entrada SQL que é disparada por uma solicitação HTTP e lê de uma consulta e retorna os resultados na resposta HTTP.

Modelo 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,
});

Modelo v3

As amostras de TypeScript não estão documentadas para o modelo v3.

Modelo 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,
        };
    },
});

Modelo v3

Veja a seguir os dados de associação no arquivo 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"
}

A seção configuração explica essas propriedades.

Veja a seguir o código JavaScript de exemplo:

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
    };
}

Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta

O exemplo a seguir mostra uma associação de entrada SQL que é disparada por uma solicitação HTTP e lê de uma consulta filtrada por um parâmetro da cadeia de caracteres de consulta e retorna a linha na resposta HTTP.

Modelo 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,
});

Modelo v3

As amostras de TypeScript não estão documentadas para o modelo v3.

Modelo 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,
        };
    },
});

Modelo v3

Veja a seguir os dados de associação no arquivo 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"
}

A seção configuração explica essas propriedades.

Veja a seguir o código JavaScript de exemplo:

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
    };
}

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma associação de entrada SQL que é disparada por uma solicitação HTTP e executa um procedimento armazenado com entrada do parâmetro de consulta de solicitação HTTP.

O procedimento armazenado dbo.DeleteToDo deve ser criado no banco de dados. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

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

Modelo 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,
});

Modelo v3

As amostras de TypeScript não estão documentadas para o modelo v3.

Modelo 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,
        };
    },
});

Modelo 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"
}

A seção configuração explica essas propriedades.

Veja a seguir o código JavaScript de exemplo:

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
    };
}

Há mais exemplos para a associação de entrada do SQL do Azure disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, obter várias linhas
• Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta
• Gatilho HTTP, excluir linhas

Os exemplos se referem a uma tabela de banco de dados:

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
);

Gatilho HTTP, obter várias linhas

O exemplo a seguir mostra uma associação de entrada SQL em um arquivo function.json e uma função do PowerShell que é disparada por uma solicitação HTTP e lê de uma consulta e retorna os resultados na resposta HTTP.

Veja a seguir os dados de associação no arquivo 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"
}

A seção configuração explica essas propriedades.

Veja a seguir um exemplo de código do PowerShell para a função no arquivo 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
})

Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta

O exemplo a seguir mostra uma associação de entrada SQL em uma função do PowerShell que é disparada por uma solicitação HTTP e lê de uma consulta filtrada por um parâmetro da cadeia de caracteres de consulta e retorna a linha na resposta HTTP.

Veja a seguir os dados de associação no arquivo 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"
}

A seção configuração explica essas propriedades.

Veja a seguir um exemplo de código do PowerShell para a função no arquivo 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
})

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma associação de entrada SQL em um arquivo function.json e uma função do PowerShell que é disparada por uma solicitação HTTP e executa um procedimento armazenado com entrada do parâmetro de consulta de solicitação HTTP.

O procedimento armazenado dbo.DeleteToDo deve ser criado no banco de dados. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

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"
}

A seção configuração explica essas propriedades.

Veja a seguir um exemplo de código do PowerShell para a função no arquivo 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
})

Há mais exemplos para a associação de entrada do SQL do Azure disponíveis no repositório do GitHub.

Esta seção contém os seguintes exemplos:

• Gatilho HTTP, obter várias linhas
• Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta
• Gatilho HTTP, excluir linhas

Os exemplos se referem a uma tabela de banco de dados:

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
);

Gatilho HTTP, obter várias linhas

O exemplo a seguir mostra uma associação de entrada SQL em um arquivo function.json e uma função Python que é disparada por uma solicitação HTTP e lê de uma consulta e retorna os resultados na resposta HTTP.

v2

Veja a seguir um exemplo de código python para o arquivo function_app.py:

import json
import logging
import azure.functions as func
from azure.functions.decorators.core import DataType

app = func.FunctionApp()

@app.function_name(name="GetToDo")
@app.route(route="gettodo")
@app.sql_input(arg_name="todo",
                        command_text="select [Id], [order], [title], [url], [completed] from dbo.ToDo",
                        command_type="Text",
                        connection_string_setting="SqlConnectionString")
def get_todo(req: func.HttpRequest, todo: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todo))

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

v1

Veja a seguir os dados de associação no arquivo 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"
}

A seção configuração explica essas propriedades.

Veja a seguir o código do Python de exemplo:

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"
    ) 

Gatilho HTTP, obter linha por ID na cadeia de caracteres de consulta

O exemplo a seguir mostra uma associação de entrada SQL em uma função Python que é disparada por uma solicitação HTTP e lê de uma consulta filtrada por um parâmetro da cadeia de caracteres de consulta e retorna a linha na resposta HTTP.

v2

Veja a seguir um exemplo de código python para o arquivo function_app.py:

import json
import logging
import azure.functions as func
from azure.functions.decorators.core import DataType

app = func.FunctionApp()

@app.function_name(name="GetToDo")
@app.route(route="gettodo/{id}")
@app.sql_input(arg_name="todo",
                        command_text="select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
                        command_type="Text",
                        parameters="@Id={id}",
                        connection_string_setting="SqlConnectionString")
def get_todo(req: func.HttpRequest, todo: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todo))

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

v1

Veja a seguir os dados de associação no arquivo 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"
}

A seção configuração explica essas propriedades.

Veja a seguir o código do Python de exemplo:

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"
    ) 

Gatilho HTTP, excluir linhas

O exemplo a seguir mostra uma associação de entrada SQL em um arquivo function.json e uma função Python que é disparada por uma solicitação HTTP e executa um procedimento armazenado com entrada do parâmetro de consulta de solicitação HTTP.

O procedimento armazenado dbo.DeleteToDo deve ser criado no banco de dados. Neste exemplo, o procedimento armazenado exclui um único registro ou todos os registros, dependendo do valor do parâmetro.

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

v2

Veja a seguir um exemplo de código python para o arquivo function_app.py:

import json
import logging
import azure.functions as func
from azure.functions.decorators.core import DataType

app = func.FunctionApp()

@app.function_name(name="DeleteToDo")
@app.route(route="deletetodo/{id}")
@app.sql_input(arg_name="todo",
                        command_text="DeleteToDo",
                        command_type="StoredProcedure",
                        parameters="@Id={id}",
                        connection_string_setting="SqlConnectionString")
def get_todo(req: func.HttpRequest, todo: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todo))

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

v1

{
    "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"
}

A seção configuração explica essas propriedades.

Veja a seguir o código do Python de exemplo:

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"
    ) 

Atributos

A biblioteca C# usa o atributo SqlAttribute para declarar as associações SQL na função, que tem as seguintes propriedades:

Propriedade de atributo	Descrição
CommandText	Obrigatórios. O comando de consulta Transact-SQL ou o nome do procedimento armazenado executado pela associação.
ConnectionStringSetting	Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual a consulta ou o procedimento armazenado está sendo executado. Esse valor não é a cadeia de conexão real e deve ser resolvido em um nome de variável de ambiente.
CommandType	Obrigatórios. Um valor CommandType, que é Text para uma consulta e StoredProcedure para um procedimento armazenado.
Parâmetros	Opcional. Zero ou mais valores de parâmetro transmitidos ao comando durante a execução como uma única cadeia de caracteres. Deve seguir o formato @param1=param1,@param2=param2. Nem o nome nem o valor do parâmetro podem conter uma vírgula (,) ou um sinal de igual (=).

Anotações

Na biblioteca de runtime de funções Java, use a anotação @SQLInput (com.microsoft.azure.functions.sql.annotation.SQLInput) nos parâmetros cujo valor viria de um SQL do Azure. Essa anotação dá suporte aos seguintes elementos:

Elemento	Descrição
commandText	Obrigatórios. O comando de consulta Transact-SQL ou o nome do procedimento armazenado executado pela associação.
connectionStringSetting	Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual a consulta ou o procedimento armazenado está sendo executado. Esse valor não é a cadeia de conexão real e deve ser resolvido em um nome de variável de ambiente.
commandType	Obrigatórios. Um valor CommandType, que é "Text" para uma consulta e "StoredProcedure" para um procedimento armazenado.
name	Obrigatórios. O nome exclusivo da associação de função.
parameters	Opcional. Zero ou mais valores de parâmetro transmitidos ao comando durante a execução como uma única cadeia de caracteres. Deve seguir o formato @param1=param1,@param2=param2. Nem o nome nem o valor do parâmetro podem conter uma vírgula (,) ou um sinal de igual (=).

Configuração

Modelo v4

A tabela a seguir explica as propriedades que você pode definir no objeto options transmitido para o método input.sql().

Propriedade	Descrição
commandText	Obrigatórios. O comando de consulta Transact-SQL ou o nome do procedimento armazenado executado pela associação.
connectionStringSetting	Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual a consulta ou o procedimento armazenado está sendo executado. Esse valor não é a cadeia de conexão real e deve ser resolvido em um nome de variável de ambiente. As palavras-chave opcionais no valor da cadeia de conexão estão disponíveis para refinar a conectividade de associações do SQL.
commandType	Obrigatórios. Um valor CommandType, que é Text para uma consulta e StoredProcedure para um procedimento armazenado.
parameters	Opcional. Zero ou mais valores de parâmetro transmitidos ao comando durante a execução como uma única cadeia de caracteres. Deve seguir o formato @param1=param1,@param2=param2. Nem o nome nem o valor do parâmetro podem conter uma vírgula (,) ou um sinal de igual (=).

Modelo v3

A tabela a seguir explica as propriedades de configuração de associação que você define no arquivo function.json.

Propriedade	Descrição
tipo	Obrigatórios. Deve ser definido como sql.
direction	Obrigatórios. Deve ser definido como in.
name	Obrigatórios. O nome da variável que representa os resultados da consulta no código da função.
commandText	Obrigatórios. O comando de consulta Transact-SQL ou o nome do procedimento armazenado executado pela associação.
connectionStringSetting	Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual a consulta ou o procedimento armazenado está sendo executado. Esse valor não é a cadeia de conexão real e deve ser resolvido em um nome de variável de ambiente. As palavras-chave opcionais no valor da cadeia de conexão estão disponíveis para refinar a conectividade de associações do SQL.
commandType	Obrigatórios. Um valor CommandType, que é Text para uma consulta e StoredProcedure para um procedimento armazenado.
parameters	Opcional. Zero ou mais valores de parâmetro transmitidos ao comando durante a execução como uma única cadeia de caracteres. Deve seguir o formato @param1=param1,@param2=param2. Nem o nome nem o valor do parâmetro podem conter uma vírgula (,) ou um sinal de igual (=).

Configuração

A tabela a seguir explica as propriedades de configuração de associação que você define no arquivo function.json.

Propriedade function.json	Descrição
tipo	Obrigatórios. Deve ser definido como sql.
direction	Obrigatórios. Deve ser definido como in.
name	Obrigatórios. O nome da variável que representa os resultados da consulta no código da função.
commandText	Obrigatórios. O comando de consulta Transact-SQL ou o nome do procedimento armazenado executado pela associação.
connectionStringSetting	Obrigatórios. O nome de uma configuração de aplicativo que contém a cadeia de conexão do banco de dados no qual a consulta ou o procedimento armazenado está sendo executado. Esse valor não é a cadeia de conexão real e deve ser resolvido em um nome de variável de ambiente. As palavras-chave opcionais no valor da cadeia de conexão estão disponíveis para refinar a conectividade de associações do SQL.
commandType	Obrigatórios. Um valor CommandType, que é Text para uma consulta e StoredProcedure para um procedimento armazenado.
parameters	Opcional. Zero ou mais valores de parâmetro transmitidos ao comando durante a execução como uma única cadeia de caracteres. Deve seguir o formato @param1=param1,@param2=param2. Nem o nome nem o valor do parâmetro podem conter uma vírgula (,) ou um sinal de igual (=).

Quando você estiver desenvolvendo localmente, adicione as configurações do aplicativo no arquivo local.settings.json na coleção Values.

Uso

O construtor do atributo usa o texto do comando, o tipo de comando, os parâmetros e o nome da configuração da cadeia de conexão do SQL. O comando pode ser uma consulta Transact-SQL (T-SQL) com o tipo de comando System.Data.CommandType.Text ou o nome do procedimento armazenado com o tipo de comando System.Data.CommandType.StoredProcedure. O nome da configuração da cadeia de conexão corresponde à configuração do aplicativo (em local.settings.json para desenvolvimento local) que contém a local.settings.json para a instância de SQL do Azure ou do SQL Server.

As consultas executadas pela associação de entrada são parametrizadas no Microsoft.Data.SqlClient para reduzir o risco de injeção de SQL dos valores de parâmetro passarem para a associação.

Se ocorrer uma exceção quando uma associação de entrada SQL for executada, o código da função não será executado. Isso pode fazer com que um código de erro seja retornado, como um gatilho HTTP retornando um código de erro 500.

Próximas etapas

• Salvar dados em um banco de dado (Associação de saída)
• Executar uma função quando os dados forem alterados em uma tabela SQL (Gatilho)
• Executar uma função a partir de uma solicitação HTTP (gatilho)
• Revisar o exemplo da API toDo com as associações SQL do Azure