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.

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:

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

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:

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 associação de entrada SQL em uma função Java que é disparada 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 associação de entrada SQL em uma função Java 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.

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 associaçã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:

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.

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

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.

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

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

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:

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:

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.

A seguir está o código python de exemplo 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"
    )

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.

A seguir está o código python de exemplo 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"
    )

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

A seguir está o código python de exemplo 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"
    )

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

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 (=).

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