Compartir vía


Enlace de salida de Azure SQL para Azure Functions

El enlace de salida de Azure SQL le permite escribir en una base de datos.

Para obtener información sobre los detalles de instalación y configuración, consulte Introducción.

Importante

En este artículo se usan pestañas para admitir varias versiones del modelo de programación de Node.js. El modelo v4 está disponible de forma general y está diseñado para que los desarrolladores de JavaScript y TypeScript tengan una experiencia más flexible e intuitiva. Para más detalles acerca de cómo funciona el modelo v4, consulte la Guía para desarrolladores de Node.js de Azure Functions. Para obtener más información sobre las diferencias entre v3 y v4, consulte la Guía de migración.

Ejemplos

Se puede crear una función C# mediante uno de los siguientes modos de C#:

  • Modelo de trabajo aislado: función compilada en C# que se ejecuta en un proceso trabajador aislado del tiempo de ejecución. Se requiere un proceso de trabajo aislado para admitir funciones de C# ejecutándose en versiones de .NET que son y no son LTS y .NET Framework.
  • Modelo en curso: función C# compilada que se ejecuta en el mismo proceso que el tiempo de ejecución de Functions.
  • Script de C#: se usa principalmente al crear funciones de C# en Azure Portal.

Hay disponibles más ejemplos para el enlace de salida de Azure SQL en el repositorio de GitHub.

En esta sección se incluyen los ejemplos siguientes:

En este ejemplo se hace referencia a una clase ToDoItem y una tabla de base de datos correspondiente:

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 devolver varios enlaces de salida en nuestros ejemplos, crearemos un tipo de valor devuelto personalizado:

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

Desencadenador HTTP, escribir un registro

En el siguiente ejemplo se muestra una función de C# que agrega un registro a una base de datos mediante los datos proporcionados en una solicitud de HTTP POST como un cuerpo JSON. El objeto a devolver es la clase OutputType que hemos creado para controlar una respuesta HTTP y el enlace de salida de 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; }
    }
}

Desencadenador HTTP, escritura en dos tablas

En el ejemplo siguiente se muestra una función de C# que agrega registros a una base de datos en dos tablas diferentes (dbo.ToDo y dbo.RequestLog), mediante datos proporcionados en una solicitud de HTTP POST como un cuerpo JSON y varios enlaces de salida.

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

Para usar un enlace de salida adicional, agregamos una clase para RequestLog y modificamos nuestra clase 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; }
    }

}

Hay disponibles más ejemplos para el enlace de salida de Azure SQL en el repositorio de GitHub.

En esta sección se incluyen los ejemplos siguientes:

En este ejemplo se hace referencia a una clase ToDoItem (en un archivo ToDoItem.java independiente) y una tabla de base de datos correspondiente:

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

Desencadenador HTTP, escritura de registros en una tabla

En el siguiente ejemplo se muestra un enlace de salida de SQL en una función de Java que agrega un registro a una tabla mediante los datos proporcionados en una solicitud de HTTP POST como un cuerpo JSON. La función toma una dependencia adicional de la biblioteca com.google.code.gson para analizar el cuerpo 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();
    }
}

Desencadenador HTTP, escritura en dos tablas

El ejemplo siguiente muestra un enlace de salida de SQL en una función de JavaS que agrega registros a una base de datos en dos tablas diferentes (dbo.ToDo y dbo.RequestLog), usando los datos proporcionados en una solicitud HTTP POST como un cuerpo JSON y varios enlaces de salida. La función toma una dependencia adicional de la biblioteca com.google.code.gson para analizar el cuerpo JSON.

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

La segunda tabla, dbo.RequestLog, corresponde a la siguiente definición:

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

y la clase de Java en 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();
    }
}

Hay disponibles más ejemplos para el enlace de salida de Azure SQL en el repositorio de GitHub.

En esta sección se incluyen los ejemplos siguientes:

Los ejemplos hacen referencia a una tabla de base de datos:

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

Desencadenador HTTP, escritura de registros en una tabla

El siguiente ejemplo muestra un enlace de salida SQL que agrega registros a una tabla, mediante los datos proporcionados en una solicitud HTTP POST como cuerpo 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 };
    },
});

Desencadenador HTTP, escritura en dos tablas

El siguiente ejemplo muestra un enlace de salida SQL que agrega registros a una base de datos en dos tablas diferentes (dbo.ToDo y dbo.RequestLog), mediante datos proporcionados en una solicitud HTTP POST como cuerpo JSON y varios enlaces de salida.

La segunda tabla, dbo.RequestLog, corresponde a la siguiente definición:

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

Hay disponibles más ejemplos para el enlace de salida de Azure SQL en el repositorio de GitHub.

En esta sección se incluyen los ejemplos siguientes:

Los ejemplos hacen referencia a una tabla de base de datos:

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

Desencadenador HTTP, escritura de registros en una tabla

En el ejemplo siguiente se muestra un enlace de salida de SQL en un archivo function.json y una función de PowerShell que agrega registros a una tabla mediante los datos proporcionados en una solicitud de HTTP POST como un cuerpo JSON.

A continuación, se muestran los datos de enlace del archivo 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"
}

En la sección de configuración se explican estas propiedades.

A continuación se muestra código de PowerShell de ejemplo para la función en el archivo 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
})

Desencadenador HTTP, escritura en dos tablas

En el ejemplo siguiente se muestra un enlace de salida de SQL en un archivo function.json y una función de PowerShell que agrega registros a una base de datos en dos tablas diferentes (dbo.ToDo y dbo.RequestLog), mediante los datos proporcionados en una solicitud de HTTP POST como un cuerpo JSON y varios enlaces de salida.

La segunda tabla, dbo.RequestLog, corresponde a la siguiente definición:

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

A continuación se muestran los datos de enlace del archivo 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"
}

En la sección de configuración se explican estas propiedades.

A continuación se muestra código de PowerShell de ejemplo para la función en el archivo 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
})

Hay disponibles más ejemplos para el enlace de salida de Azure SQL en el repositorio de GitHub.

En esta sección se incluyen los ejemplos siguientes:

Los ejemplos hacen referencia a una tabla de base de datos:

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

Desencadenador HTTP, escritura de registros en una tabla

En el ejemplo siguiente se muestra un enlace de salida de SQL en un archivo function.json y una función de Python que agrega registros a una tabla, mediante los datos proporcionados en una solicitud de HTTP POST como un cuerpo JSON.

A continuación se muestra código python de ejemplo para el archivo 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"
    )

Desencadenador HTTP, escritura en dos tablas

En el ejemplo siguiente se muestra un enlace de salida de SQL en un archivo function.json y una función de Python que agrega registros a una base de datos en dos tablas diferentes (dbo.ToDo y dbo.RequestLog), mediante los datos proporcionados en una solicitud de HTTP POST como un cuerpo JSON y varios enlaces de salida.

La segunda tabla, dbo.RequestLog, corresponde a la siguiente definición:

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

A continuación se muestra código python de ejemplo para el archivo 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

La biblioteca de C# usa el atributo SqlAttribute para declarar los enlaces SQL en la función, que tiene las siguientes propiedades:

Propiedad de atributo Descripción
CommandText Necesario. Nombre de la tabla en la que se escribe el enlace.
ConnectionStringSetting Necesario. Nombre de una configuración de aplicación que contiene la cadena de conexión de la base de datos en que se escriben los datos. No es la cadena de conexión real y, en su lugar, debe resolverse en una variable de entorno.

anotaciones

En la biblioteca de runtime de funciones de Java, utilice la anotación @SQLOutput (com.microsoft.azure.functions.sql.annotation.SQLOutput) en los parámetros cuyo valor provendría de Azure SQL. Esta anotación admite los siguientes elementos:

Elemento Descripción
commandText Necesario. Nombre de la tabla en la que se escribe el enlace.
connectionStringSetting Necesario. Nombre de una configuración de aplicación que contiene la cadena de conexión de la base de datos en que se escriben los datos. No es la cadena de conexión real y, en su lugar, debe resolverse en una variable de entorno.
name Necesario. Nombre único del enlace de la función.

Configuración

En la tabla siguiente se explican las propiedades que puede establecer en el objeto options que se pasa al métodooutput.sql().

Propiedad Descripción
commandText Necesario. Nombre de la tabla en la que se escribe el enlace.
connectionStringSetting Necesario. Nombre de una configuración de aplicación que contiene la cadena de conexión de la base de datos en que se escriben los datos. No es la cadena de conexión real y, en su lugar, debe resolverse en una variable de entorno. Las palabras clave opcionales del valor de cadena de conexión están disponibles para mejorar la conectividad de los enlaces SQL.

Configuración

En la siguiente tabla se explican las propiedades de configuración de enlace que se establecen en el archivo function.json.

Propiedad de function.json Descripción
type Necesario. Se debe establecer en sql.
direction Necesario. Se debe establecer en out.
name Necesario. Nombre de la variable que representa la entidad en el código de la función.
commandText Necesario. Nombre de la tabla en la que se escribe el enlace.
connectionStringSetting Necesario. Nombre de una configuración de aplicación que contiene la cadena de conexión de la base de datos en que se escriben los datos. No es la cadena de conexión real y, en su lugar, debe resolverse en una variable de entorno. Las palabras clave opcionales del valor de cadena de conexión están disponibles para mejorar la conectividad de los enlaces SQL.

Cuando esté desarrollando localmente, agregue la configuración de la aplicación en el archivo local.settings.json de la colección Values.

Uso

La propiedad CommandText es el nombre de la tabla en que se van a almacenar los datos. El nombre de la configuración de la cadena de conexión se corresponde con la configuración de la aplicación que contiene la cadena de conexión a la instancia de Azure SQL o SQL Server.

Los enlaces de salida usan la instrucción MERGE de T-SQL, que requiere permisos SELECT en la base de datos de destino.

Si se produce una excepción cuando se ejecuta un enlace de salida SQL, el código de función deja de ejecutarse. Esto puede dar lugar a que se devuelva un código de error, como un desencadenador HTTP que devuelve un código de error 500. Si se usa IAsyncCollector en una función de .NET, el código de función puede controlar las excepciones producidas por la llamada a FlushAsync().

Pasos siguientes