Azure SQL-uitvoerbinding voor Azure Functions

Met de Azure SQL-uitvoerbinding kunt u schrijven naar een database.

Zie het overzicht voor informatie over het instellen en configureren van details.

Belangrijk

In dit artikel worden tabbladen gebruikt ter ondersteuning van meerdere versies van het Node.js programmeermodel. Het v4-model is algemeen beschikbaar en is ontworpen voor een flexibelere en intuïtievere ervaring voor JavaScript- en TypeScript-ontwikkelaars. Raadpleeg de ontwikkelaarshandleiding voor Azure Functions Node.js voor meer informatie over hoe het v4-model werkt. Raadpleeg de migratiehandleiding voor meer informatie over de verschillen tussen v3 en v4.

Voorbeelden

U kunt een C#-functie maken met behulp van een van de volgende C#-modi:

• Geïsoleerd werkrolmodel: gecompileerde C#-functie die wordt uitgevoerd in een werkproces dat is geïsoleerd van de runtime. Geïsoleerd werkproces is vereist voor de ondersteuning van C#-functies die worden uitgevoerd op LTS- en niet-LTS-versies .NET en .NET Framework.
• In-process model: gecompileerde C#-functie die wordt uitgevoerd in hetzelfde proces als de Functions-runtime.
• C#-script: wordt voornamelijk gebruikt wanneer u C#-functies maakt in Azure Portal.

Belangrijk

De ondersteuning wordt beëindigd voor het in-process model op 10 november 2026. We raden u ten zeerste aan uw apps te migreren naar het geïsoleerde werkrolmodel voor volledige ondersteuning.

Geïsoleerde werkrolmodel

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

• HTTP-trigger, één record schrijven
• HTTP-trigger, schrijven naar twee tabellen

De voorbeelden verwijzen naar een ToDoItem klasse en een bijbehorende databasetabel:

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

Als u meerdere uitvoerbindingen in onze voorbeelden wilt retourneren, maken we een aangepast retourtype:

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

HTTP-trigger, één record schrijven

In het volgende voorbeeld ziet u een C#-functie waarmee een record wordt toegevoegd aan een database, waarbij gegevens worden gebruikt die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst. Het retourobject is de OutputType klasse die we hebben gemaakt om zowel een HTTP-antwoord als de SQL-uitvoerbinding te verwerken.

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

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een C#-functie die records toevoegt aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

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

Als u een extra uitvoerbinding wilt gebruiken, voegen we een klasse toe voor RequestLog en wijzigen we onze OutputType klasse:

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

}

Model in proces

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

• HTTP-trigger, één record schrijven
• HTTP-trigger, schrijven naar twee tabellen
• HTTP-trigger, records schrijven met IAsyncCollector

De voorbeelden verwijzen naar een ToDoItem klasse en een bijbehorende databasetabel:

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

HTTP-trigger, één record schrijven

In het volgende voorbeeld ziet u een C#-functie waarmee een record wordt toegevoegd aan een database, waarbij gegevens worden gebruikt die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.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<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "dbo.ToDo", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<ToDoItem> toDoItems)
        {
            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;
            }

            await toDoItems.AddAsync(toDoItem);
            await toDoItems.FlushAsync();
            List<ToDoItem> toDoItemList = new List<ToDoItem> { toDoItem };

            return new OkObjectResult(toDoItemList);
        }
    }
}

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een C#-functie die records toevoegt aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

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

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<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "dbo.ToDo", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<ToDoItem> toDoItems,
            [Sql(commandText: "dbo.RequestLog", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<RequestLog> requestLogs)
        {
            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;
            }

            await toDoItems.AddAsync(toDoItem);
            await toDoItems.FlushAsync();
            List<ToDoItem> toDoItemList = new List<ToDoItem> { toDoItem };

            requestLog = new RequestLog();
            requestLog.RequestTimeStamp = DateTime.Now;
            requestLog.ItemCount = 1;
            await requestLogs.AddAsync(requestLog);
            await requestLogs.FlushAsync();

            return new OkObjectResult(toDoItemList);
        }
    }

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

HTTP-trigger, records schrijven met IAsyncCollector

In het volgende voorbeeld ziet u een C#-functie waarmee een verzameling records aan een database wordt toegevoegd met behulp van gegevens die zijn opgegeven in een JSON-matrix van de HTTP POST-hoofdtekst.

using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Newtonsoft.Json;
using System.IO;
using System.Threading.Tasks;

namespace AzureSQLSamples
{
    public static class WriteRecordsAsync
    {
        [FunctionName("WriteRecordsAsync")]
        public static async Task<IActionResult> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "addtodo-asynccollector")]
            HttpRequest req,
            [Sql(commandText: "dbo.ToDo", connectionStringSetting: "SqlConnectionString")] IAsyncCollector<ToDoItem> newItems)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            var incomingItems = JsonConvert.DeserializeObject<ToDoItem[]>(requestBody);
            foreach (ToDoItem newItem in incomingItems)
            {
                await newItems.AddAsync(newItem);
            }
            // Rows are upserted here
            await newItems.FlushAsync();

            return new CreatedResult($"/api/addtodo-asynccollector", "done");
        }
    }
}

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

• HTTP-trigger, een record naar een tabel schrijven
• HTTP-trigger, schrijven naar twee tabellen

De voorbeelden verwijzen naar een ToDoItem klasse (in een afzonderlijk bestand ToDoItem.java) en een bijbehorende databasetabel:

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

HTTP-trigger, een record naar een tabel schrijven

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een Java-functie waarmee een record aan een tabel wordt toegevoegd, met behulp van gegevens in een HTTP POST-aanvraag als JSON-hoofdtekst. De functie heeft een extra afhankelijkheid van de com.google.code.gson-bibliotheek om de JSON-hoofdtekst te parseren.

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

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een JavaS-functie die records toevoegt aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen. De functie heeft een extra afhankelijkheid van de com.google.code.gson-bibliotheek om de JSON-hoofdtekst te parseren.

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

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

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

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

• HTTP-trigger, records schrijven naar een tabel
• HTTP-trigger, schrijven naar twee tabellen

De voorbeelden verwijzen naar een databasetabel:

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

HTTP-trigger, records schrijven naar een tabel

In het volgende voorbeeld ziet u een SQL-uitvoerbinding waarmee records aan een tabel worden toegevoegd met behulp van gegevens in een HTTP POST-aanvraag als JSON-hoofdtekst.

Model v4

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

Model v3

TypeScript-voorbeelden worden niet gedocumenteerd voor model v3.

Model v4

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

Model v3

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een voorbeeld van JavaScript-code:

module.exports = async function (context, req) {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    context.bindings.todoItems = req.body;
    context.res = {
        status: 201
    }
}

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding die records toevoegt aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

Model v4

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

Model v3

TypeScript-voorbeelden worden niet gedocumenteerd voor model v3.

Model v4

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

Model v3

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een voorbeeld van JavaScript-code:

module.exports = async function (context, req) {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    const newLog = {
        RequestTimeStamp: Date.now(),
        ItemCount: 1
    };
    context.bindings.requestLog = newLog;

    context.bindings.todoItems = req.body;
    context.res = {
        status: 201
    }
}

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

• HTTP-trigger, records schrijven naar een tabel
• HTTP-trigger, schrijven naar twee tabellen

De voorbeelden verwijzen naar een databasetabel:

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

HTTP-trigger, records schrijven naar een tabel

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een PowerShell-functie waarmee records worden toegevoegd aan een tabel, waarbij gegevens worden gebruikt die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst.

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een PowerShell-voorbeeldcode voor de functie in het run.ps1 bestand:

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

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een PowerShell-functie waarmee records worden toegevoegd aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een PowerShell-voorbeeldcode voor de functie in het run.ps1 bestand:

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

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

• HTTP-trigger, records schrijven naar een tabel
• HTTP-trigger, schrijven naar twee tabellen

De voorbeelden verwijzen naar een databasetabel:

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

HTTP-trigger, records schrijven naar een tabel

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een Python-functie waarmee records worden toegevoegd aan een tabel, waarbij gegevens worden gebruikt die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst.

v2

Hier volgt een python-voorbeeldcode voor het function_app.py-bestand:

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

v1

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een voorbeeld van Python-code:

import logging
import azure.functions as func


def main(req: func.HttpRequest, todoItems: 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

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

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een Python-functie waarmee records worden toegevoegd aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

v2

Hier volgt een python-voorbeeldcode voor het function_app.py-bestand:

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
        )

v1

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een voorbeeld van Python-code:

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


def main(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(),
        "ItemCount": 1
    }))

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

Kenmerken

De C#-bibliotheek maakt gebruik van het kenmerk SqlAttribute om de SQL-bindingen voor de functie te declareren, die de volgende eigenschappen heeft:

Kenmerkeigenschap	Beschrijving
CommandText	Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
ConnectionStringSetting	Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele.

Aantekeningen

Gebruik in de Java Functions Runtime-bibliotheek de @SQLOutput aantekening (com.microsoft.azure.functions.sql.annotation.SQLOutput) voor parameters waarvan de waarde afkomstig is van Azure SQL. Deze aantekening ondersteunt de volgende elementen:

Element	Beschrijving
commandText	Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
connectionStringSetting	Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele.
name	Vereist. De unieke naam van de functiebinding.

Configuratie

Model v4

In de volgende tabel worden de eigenschappen uitgelegd die u kunt instellen voor het options object dat aan de output.sql() methode is doorgegeven.

Eigenschappen	Beschrijving
commandText	Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
connectionStringSetting	Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele. Optionele trefwoorden in de verbindingsreeks-waarde zijn beschikbaar om de connectiviteit van SQL-bindingen te verfijnen.

Model v3

In de volgende tabel worden de bindingsconfiguratie-eigenschappen uitgelegd die u in het function.json-bestand hebt ingesteld.

Eigenschappen	Beschrijving
type	Vereist. Moet worden ingesteld op sql.
direction	Vereist. Moet worden ingesteld op out.
name	Vereist. De naam van de variabele die de entiteit in functiecode vertegenwoordigt.
commandText	Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
connectionStringSetting	Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele. Optionele trefwoorden in de verbindingsreeks-waarde zijn beschikbaar om de connectiviteit van SQL-bindingen te verfijnen.

Configuratie

In de volgende tabel worden de bindingsconfiguratie-eigenschappen uitgelegd die u in het function.json-bestand hebt ingesteld.

function.json-eigenschap	Beschrijving
type	Vereist. Moet worden ingesteld op sql.
direction	Vereist. Moet worden ingesteld op out.
name	Vereist. De naam van de variabele die de entiteit in functiecode vertegenwoordigt.
commandText	Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
connectionStringSetting	Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele. Optionele trefwoorden in de verbindingsreeks-waarde zijn beschikbaar om de connectiviteit van SQL-bindingen te verfijnen.

Wanneer u lokaal ontwikkelt, voegt u uw toepassingsinstellingen toe aan het local.settings.json-bestand in de Values verzameling.

Gebruik

De CommandText eigenschap is de naam van de tabel waarin de gegevens moeten worden opgeslagen. De naam van de verbindingsreeks-instelling komt overeen met de toepassingsinstelling die de verbindingsreeks bevat naar het Azure SQL- of SQL Server-exemplaar.

De uitvoerbindingen maken gebruik van de T-SQL MERGE-instructie waarvoor SELECT-machtigingen zijn vereist voor de doeldatabase.

Als er een uitzondering optreedt wanneer een SQL-uitvoerbinding wordt uitgevoerd, stopt de functiecode met uitvoeren. Dit kan ertoe leiden dat er een foutcode wordt geretourneerd, zoals een HTTP-trigger die een 500-foutcode retourneert. Als de IAsyncCollector functie wordt gebruikt in een .NET-functie, kan de functiecode uitzonderingen verwerken die worden veroorzaakt door de aanroep naar FlushAsync().

Volgende stappen

• Gegevens lezen uit een database (invoerbinding)
• Een functie uitvoeren wanneer gegevens worden gewijzigd in een SQL-tabel (trigger)
• ToDo-API-voorbeeld controleren met Azure SQL-bindingen