Associações de saída do SQL do Azure para o Azure Functions

A associação de saída do SQL do Azure permite gravar em um banco de dados.

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 saída 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
);

Para retornar várias ligações de saída em nossos exemplos, criaremos um tipo de retorno personalizado:

public static class OutputType
{
    [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
    public ToDoItem ToDoItem { get; set; }
    public HttpResponseData HttpResponse { get; set; }
}

Gatilho HTTP, gravar um registro

O exemplo a seguir mostra uma função C# que adiciona um registro a um banco de dados, usando os dados fornecidos em uma solicitação HTTP POST como um corpo JSON. O objeto de retorno é a classe OutputType que criamos para lidar com uma resposta HTTP e a associação de saída do SQL.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("PostToDo");
            logger.LogInformation("C# HTTP trigger function processed a request.");

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            return new OutputType()
            {
                ToDoItem = toDoItem,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

    public static class OutputType
    {
        [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
        public ToDoItem ToDoItem { get; set; }

        public HttpResponseData HttpResponse { get; set; }
    }
}

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma função C# que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Para usar uma associação de saída adicional, adicionamos uma classe para RequestLog e modificamos nossa classe OutputType:

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            requestLog = new RequestLog();
            requestLog.RequestTimeStamp = DateTime.Now;
            requestLog.ItemCount = 1;

            return new OutputType()
            {
                ToDoItem = toDoItem,
                RequestLog = requestLog,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

    public class RequestLog {
        public DateTime RequestTimeStamp { get; set; }
        public int ItemCount { get; set; }
    }

    public static class OutputType
    {
        [SqlOutput("dbo.ToDo", connectionStringSetting: "SqlConnectionString")]
        public ToDoItem ToDoItem { get; set; }

        [SqlOutput("dbo.RequestLog", connectionStringSetting: "SqlConnectionString")]
        public RequestLog RequestLog { get; set; }

        public HttpResponseData HttpResponse { get; set; }
    }

}

Mais exemplos para a associação de saída 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, gravar um registro em uma tabela

O exemplo a seguir mostra uma associação de saída SQL em uma função Java que adiciona um registro a uma tabela, usando os dados fornecidos em uma solicitação HTTP POST como um corpo JSON. A função usa uma dependência adicional da biblioteca com.google.code.gson para analisar o corpo JSON.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>
package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.sql.annotation.SQLOutput;
import com.google.gson.Gson;

import java.util.Optional;

public class PostToDo {
    @FunctionName("PostToDo")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output) {
        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);

        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

        return request.createResponseBuilder(HttpStatus.CREATED).header("Content-Type", "application/json").body(output).build();
    }
}

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de saída do SQL em uma função JavaS que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída. A função usa uma dependência adicional da biblioteca com.google.code.gson para analisar o corpo JSON.

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id INT IDENTITY(1,1) PRIMARY KEY,
    RequestTimeStamp DATETIME2 NOT NULL DEFAULT(GETDATE()),
    ItemCount INT NOT NULL
)

e a classe Java em RequestLog.java:

package com.function;

import java.util.Date;

public class RequestLog {
    public int Id;
    public Date RequestTimeStamp;
    public int ItemCount;

    public RequestLog() {
    }

    public RequestLog(int Id, Date RequestTimeStamp, int ItemCount) {
        this.Id = Id;
        this.RequestTimeStamp = RequestTimeStamp;
        this.ItemCount = ItemCount;
    }
}
package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.sql.annotation.SQLOutput;
import com.google.gson.Gson;

import java.util.Optional;

public class PostToDoWithLog {
    @FunctionName("PostToDoWithLog")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output,
            @SQLOutput(
                name = "requestLog",
                commandText = "dbo.RequestLog",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<RequestLog> outputLog,
            final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");

        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);
        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

        RequestLog newLog = new RequestLog();
        newLog.ItemCount = 1;
        outputLog.setValue(newLog);

        return request.createResponseBuilder(HttpStatus.CREATED).header("Content-Type", "application/json").body(output).build();
    }
}

Mais exemplos para a associação de saída 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, gravar registros em uma tabela

O exemplo a seguir mostra uma ligação de saída do SQL que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

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

const sqlOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    const body = await request.json();
    context.extraOutputs.set(sqlOutput, body);
    return { status: 201 };
}

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlOutput],
    handler: httpTrigger1,
});
const { app, output } = require('@azure/functions');

const sqlOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlOutput],
    handler: async (request, context) => {
        context.log('HTTP trigger and SQL output binding function processed a request.');

        const body = await request.json();
        context.extraOutputs.set(sqlOutput, body);
        return { status: 201 };
    },
});

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de saída do SQL adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando os dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)
import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const sqlTodoOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

const sqlRequestLogOutput = output.sql({
    commandText: 'dbo.RequestLog',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    const newLog = {
        RequestTimeStamp: Date.now(),
        ItemCount: 1,
    };
    context.extraOutputs.set(sqlRequestLogOutput, newLog);

    const body = await request.json();
    context.extraOutputs.set(sqlTodoOutput, body);

    return { status: 201 };
}

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlTodoOutput, sqlRequestLogOutput],
    handler: httpTrigger1,
});
const { app, output } = require('@azure/functions');

const sqlTodoOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

const sqlRequestLogOutput = output.sql({
    commandText: 'dbo.RequestLog',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlTodoOutput, sqlRequestLogOutput],
    handler: async (request, context) => {
        context.log('HTTP trigger and SQL output binding function processed a request.');

        const newLog = {
            RequestTimeStamp: Date.now(),
            ItemCount: 1,
        };
        context.extraOutputs.set(sqlRequestLogOutput, newLog);

        const body = await request.json();
        context.extraOutputs.set(sqlTodoOutput, body);

        return { status: 201 };
    },
});

Mais exemplos para a associação de saída 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, gravar registros em uma tabela

O exemplo a seguir mostra uma associação de saída do SQL em um arquivo function.json e uma função do PowerShell que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

Veja a seguir os dados de associação no arquivo function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
}

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

Veja o seguinte exemplo de código do PowerShell para a função no arquivo run.ps1:


```powershell
using namespace System.Net

param($Request)

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

# Update req_body with the body of the request
$req_body = $Request.Body

# Assign the value we want to pass to the SQL Output binding. 
# The -Name value corresponds to the name property in the function.json for the binding
Push-OutputBinding -Name todoItems -Value $req_body

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

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de entrada do SQL em um arquivo function.json e uma função do PowerShell que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

Veja a seguir os dados de associação no arquivo function.json:

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "post"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.ToDo",
    "connectionStringSetting": "SqlConnectionString"
},
{
    "name": "requestLog",
    "type": "sql",
    "direction": "out",
    "commandText": "dbo.RequestLog",
    "connectionStringSetting": "SqlConnectionString"
}

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

Veja o seguinte exemplo de código do PowerShell para a função no arquivo run.ps1:

using namespace System.Net

param($Request)

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

# Update req_body with the body of the request
$req_body = $Request.Body
$new_log = @{
    RequestTimeStamp = [DateTime]::Now
    ItemCount = 1
}

Push-OutputBinding -Name todoItems -Value $req_body
Push-OutputBinding -Name requestLog -Value $new_log

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

Mais exemplos para a associação de saída 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, gravar registros em uma tabela

O exemplo a seguir mostra uma associação de saída do SQL em um arquivo function.json e uma função do Python que adiciona registros a uma tabela, usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON.

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="AddToDo")
@app.route(route="addtodo")
@app.sql_output(arg_name="todo",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todo: func.Out[func.SqlRow]) -> func.HttpResponse:
    body = json.loads(req.get_body())
    row = func.SqlRow.from_dict(body)
    todo.set(row)

    return func.HttpResponse(
        body=req.get_body(),
        status_code=201,
        mimetype="application/json"
    )

Gatilho HTTP, gravação em duas tabelas

O exemplo a seguir mostra uma associação de saída do SQL em um arquivo function.json e uma função do Python que adiciona registros a um banco de dados em duas tabelas diferentes (dbo.ToDo e dbo.RequestLog), usando dados fornecidos em uma solicitação HTTP POST como um corpo JSON e várias associações de saída.

A segunda tabela, dbo.RequestLog, corresponde à seguinte definição:

CREATE TABLE dbo.RequestLog (
    Id int identity(1,1) primary key,
    RequestTimeStamp datetime2 not null,
    ItemCount int not null
)

A seguir está o código python de exemplo para o arquivo function_app.py:

from datetime import datetime
import json
import logging
import azure.functions as func

app = func.FunctionApp()

@app.function_name(name="PostToDo")
@app.route(route="posttodo")
@app.sql_output(arg_name="todoItems",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
@app.sql_output(arg_name="requestLog",
                        command_text="[dbo].[RequestLog]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todoItems: func.Out[func.SqlRow], requestLog: func.Out[func.SqlRow]) -> func.HttpResponse:
    logging.info('Python HTTP trigger and SQL output binding function processed a request.')
    try:
        req_body = req.get_json()
        rows = func.SqlRowList(map(lambda r: func.SqlRow.from_dict(r), req_body))
    except ValueError:
        pass

    requestLog.set(func.SqlRow({
        "RequestTimeStamp": datetime.now().isoformat(),
        "ItemCount": 1
    }))

    if req_body:
        todoItems.set(rows)
        return func.HttpResponse(
            "OK",
            status_code=201,
            mimetype="application/json"
        )
    else:
        return func.HttpResponse(
            "Error accessing request body",
            status_code=400
        )

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 nome da tabela que está sendo gravada 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 os dados estão sendo gravados. Essa não é a cadeia de conexão real e deve ser resolvida para uma variável de ambiente.

Anotações

Na biblioteca de runtime de funções Java, use a anotação @SQLOutput (com.microsoft.azure.functions.sql.annotation.SQLOutput) 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 nome da tabela que está sendo gravada 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 os dados estão sendo gravados. Essa não é a cadeia de conexão real e deve ser resolvida para uma variável de ambiente.
name Obrigatórios. O nome exclusivo da associação de função.

Configuração

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

Propriedade Descrição
commandText Obrigatórios. O nome da tabela que está sendo gravada 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 os dados estão sendo gravados. Essa não é a cadeia de conexão real e deve ser resolvida para uma 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.

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 out.
name Obrigatórios. O nome da variável que representa a entidade no código da função.
commandText Obrigatórios. O nome da tabela que está sendo gravada 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 os dados estão sendo gravados. Essa não é a cadeia de conexão real e deve ser resolvida para uma 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.

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

Uso

A propriedade CommandText é o nome da tabela em que os dados devem ser armazenados. O nome da configuração da cadeia de conexão corresponde à configuração do aplicativo que contém a cadeia de conexão para a instância do SQL do Azure ou do SQL Server.

As associações de saída usam a instrução T-SQL MERGE que exige permissões SELECT no banco de dados de destino.

Se ocorrer uma exceção quando uma associação de saída SQL for executada, o código de função interromperá a execução. Isso pode fazer com que um código de erro seja retornado, como um gatilho HTTP retornando um código de erro 500. Se o IAsyncCollector for usado em uma função .NET, o código de função poderá lidar com exceções geradas pela chamada para FlushAsync().

Próximas etapas