Associazione di output SQL di Azure per Funzioni di Azure

  • Articolo

L'associazione di output SQL di Azure consente di scrivere in un database.

Per informazioni sui dettagli di impostazione e configurazione, vedere la panoramica.

Importante

Questo articolo usa schede per supportare più versioni del modello di programmazione Node.js. Il modello v4 è disponibile a livello generale ed è progettato per offrire un'esperienza più flessibile e intuitiva per gli sviluppatori JavaScript e TypeScript. Per altre informazioni sul funzionamento del modello v4, vedere la guida per sviluppatori di Funzioni di Azure Node.js. Per altre informazioni sulle differenze tra v3 e v4, vedere la guida alla migrazione.

Esempi

È possibile creare una funzione C# usando una delle modalità C# seguenti:

  • Modello di lavoro isolato: funzione C# compilata eseguita in un processo di lavoro isolato dal runtime. Il processo di lavoro isolato è necessario per supportare le funzioni C# in esecuzione in LTS e versioni non LTS .NET e .NET Framework.
  • Modello in-process: funzione C# compilata eseguita nello stesso processo del runtime di Funzioni.
  • Script C#: usato principalmente quando si creano funzioni C# nel portale di Azure.

Importante

Il supporto terminerà per il modello in-process il 10 novembre 2026. È consigliabile eseguire la migrazione delle app al modello di lavoro isolato per il supporto completo.

Altri esempi per l'associazione di output SQL di Azure sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

Gli esempi fanno riferimento a una ToDoItem classe e a una tabella di database corrispondente:

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

Per restituire più associazioni di output negli esempi, verrà creato un tipo restituito personalizzato:

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

Trigger HTTP, scrittura di un record

L'esempio seguente illustra una funzione C# che aggiunge un record a un database, usando i dati forniti in una richiesta HTTP POST come corpo JSON. L'oggetto restituito è la OutputType classe creata per gestire sia una risposta HTTP che l'associazione di output 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; }
    }
}

Trigger HTTP, scrittura in due tabelle

L'esempio seguente illustra una funzione C# che aggiunge record a un database in due tabelle diverse (dbo.ToDo e dbo.RequestLog), usando i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output.

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

Per usare un'associazione di output aggiuntiva, si aggiunge una classe per RequestLog e si modifica la OutputType classe :

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

}

Altri esempi per l'associazione di output SQL di Azure sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

Gli esempi fanno riferimento a una ToDoItem classe (in un file ToDoItem.javaseparato ) e a una tabella di database corrispondente:

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

Trigger HTTP, scrivere un record in una tabella

L'esempio seguente mostra un'associazione di output SQL in una funzione Java che aggiunge un record a una tabella, usando i dati forniti in una richiesta HTTP POST come corpo JSON. La funzione accetta una dipendenza aggiuntiva dalla libreria com.google.code.gson per analizzare il 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();
    }
}

Trigger HTTP, scrittura in due tabelle

L'esempio seguente illustra un'associazione di output SQL in una funzione JavaS che aggiunge record a un database in due tabelle diverse (dbo.ToDo e dbo.RequestLog), usando i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output. La funzione accetta una dipendenza aggiuntiva dalla libreria com.google.code.gson per analizzare il corpo JSON.

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

La seconda tabella, dbo.RequestLog, corrisponde alla definizione seguente:

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

e la classe Java in 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();
    }
}

Altri esempi per l'associazione di output SQL di Azure sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

Gli esempi fanno riferimento a una tabella di database:

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

Trigger HTTP, scrittura di record in una tabella

L'esempio seguente mostra un'associazione di output SQL che aggiunge record a una tabella, usando i dati forniti in una richiesta HTTP POST come 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 };
    },
});

Trigger HTTP, scrittura in due tabelle

L'esempio seguente illustra un'associazione di output SQL che aggiunge record a un database in due tabelle diverse (dbo.ToDo e dbo.RequestLog), usando i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output.

La seconda tabella, dbo.RequestLog, corrisponde alla definizione seguente:

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

Altri esempi per l'associazione di output SQL di Azure sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

Gli esempi fanno riferimento a una tabella di database:

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

Trigger HTTP, scrittura di record in una tabella

L'esempio seguente illustra un'associazione di output SQL in un file function.json e una funzione di PowerShell che aggiunge record a una tabella, usando i dati forniti in una richiesta HTTP POST come corpo JSON.

Di seguito sono riportati i dati di associazione nel file 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"
}

Queste proprietà sono descritte nella sezione configuration.

Di seguito è riportato il codice di PowerShell di esempio per la funzione nel run.ps1 file :


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

Trigger HTTP, scrittura in due tabelle

L'esempio seguente illustra un'associazione di output SQL in un file function.json e una funzione di PowerShell che aggiunge record a un database in due tabelle diverse (dbo.ToDo e dbo.RequestLog), usando i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output.

La seconda tabella, dbo.RequestLog, corrisponde alla definizione seguente:

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

Di seguito sono riportati i dati di associazione nel file 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"
}

Queste proprietà sono descritte nella sezione configuration.

Di seguito è riportato il codice di PowerShell di esempio per la funzione nel run.ps1 file :

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

Altri esempi per l'associazione di output SQL di Azure sono disponibili nel repository GitHub.

Questa sezione contiene gli esempi seguenti:

Gli esempi fanno riferimento a una tabella di database:

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

Trigger HTTP, scrittura di record in una tabella

L'esempio seguente illustra un'associazione di output SQL in un file function.json e una funzione Python che aggiunge record a una tabella, usando i dati forniti in una richiesta HTTP POST come corpo JSON.

Di seguito è riportato il codice Python di esempio per il file 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"
    )

Trigger HTTP, scrittura in due tabelle

L'esempio seguente illustra un'associazione di output SQL in un file function.json e una funzione Python che aggiunge record a un database in due tabelle diverse (dbo.ToDo e dbo.RequestLog), usando i dati forniti in una richiesta HTTP POST come corpo JSON e più associazioni di output.

La seconda tabella, dbo.RequestLog, corrisponde alla definizione seguente:

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

Di seguito è riportato il codice Python di esempio per il file 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
        )

Attributi

La libreria C# usa l'attributo SqlAttribute per dichiarare le associazioni SQL nella funzione, con le proprietà seguenti:

Proprietà dell'attributo Descrizione
CommandText Obbligatorio. Nome della tabella in cui viene scritto dall'associazione.
ConnectionStringSetting Obbligatorio. Nome di un'impostazione dell'app che contiene il stringa di connessione per il database in cui vengono scritti i dati. Questo non è il stringa di connessione effettivo e deve invece risolvere in una variabile di ambiente.

Annotazioni

Nella libreria di runtime delle funzioni Java usare l'annotazione @SQLOutput (com.microsoft.azure.functions.sql.annotation.SQLOutput) nei parametri il cui valore proviene da Azure SQL. Questa annotazione supporta gli elementi seguenti:

Elemento Descrizione
commandText Obbligatorio. Nome della tabella in cui viene scritto dall'associazione.
connectionStringSetting Obbligatorio. Nome di un'impostazione dell'app che contiene il stringa di connessione per il database in cui vengono scritti i dati. Questo non è il stringa di connessione effettivo e deve invece risolvere in una variabile di ambiente.
name Obbligatorio. Nome univoco dell'associazione di funzioni.

Impostazione

Nella tabella seguente vengono illustrate le proprietà che è possibile impostare sull'oggetto options passato al output.sql() metodo .

Proprietà Descrizione
commandText Obbligatorio. Nome della tabella in cui viene scritto dall'associazione.
connectionStringSetting Obbligatorio. Nome di un'impostazione dell'app che contiene il stringa di connessione per il database in cui vengono scritti i dati. Questo non è il stringa di connessione effettivo e deve invece risolvere in una variabile di ambiente. Le parole chiave facoltative nel valore stringa di connessione sono disponibili per perfezionare la connettività delle associazioni SQL.

Impostazione

Nella tabella seguente sono illustrate le proprietà di configurazione dell'associazione impostate nel file function.json.

Proprietà di function.json Descrizione
type Obbligatorio. Deve essere impostato su sql.
direction Obbligatorio. Deve essere impostato su out.
name Obbligatorio. Nome della variabile che rappresenta l'entità nel codice della funzione.
commandText Obbligatorio. Nome della tabella in cui viene scritto dall'associazione.
connectionStringSetting Obbligatorio. Nome di un'impostazione dell'app che contiene il stringa di connessione per il database in cui vengono scritti i dati. Questo non è il stringa di connessione effettivo e deve invece risolvere in una variabile di ambiente. Le parole chiave facoltative nel valore stringa di connessione sono disponibili per perfezionare la connettività delle associazioni SQL.

Quando si sviluppa in locale, aggiungere le impostazioni dell'applicazione nel file local.settings.json nella Values raccolta.

Utilizzo

La CommandText proprietà è il nome della tabella in cui archiviare i dati. Il nome dell'impostazione stringa di connessione corrisponde all'impostazione dell'applicazione che contiene il stringa di connessione all'istanza di SQL di Azure o SQL Server.

Le associazioni di output usano l'istruzione T-SQL MERGE che richiede autorizzazioni SELECT per il database di destinazione.

Se si verifica un'eccezione quando viene eseguita un'associazione di output SQL, il codice della funzione smette di eseguire. Ciò può comportare la restituzione di un codice di errore, ad esempio un trigger HTTP che restituisce un codice di errore 500. IAsyncCollector Se viene usato in una funzione .NET, il codice della funzione può gestire le eccezioni generate dalla chiamata a FlushAsync().

Passaggi successivi