Azure SQL-Ausgabebindung für Azure Functions

Mit der Azure SQL-Ausgabebindung können Sie in eine Datenbank schreiben.

Informationen zu Setup- und Konfigurationsdetails finden Sie in der Übersicht.

Wichtig

In diesem Artikel werden Registerkarten verwendet, um mehrere Versionen des Node.js-Programmiermodells zu unterstützen. Das v4-Modell ist allgemein verfügbar und bietet JavaScript- und TypeScript-Entwicklern eine flexiblere und intuitivere Erfahrung. Weitere Informationen zur Funktionsweise des v4-Modells finden Sie im Azure Functions Node.js-Entwicklerhandbuch. Weitere Informationen zu den Unterschieden zwischen v3 und v4 finden Sie im Migrationshandbuch.

Beispiele

Eine C#-Funktion kann mit einem der folgenden C#-Modi erstellt werden:

• Isoliertes Workermodell: Kompilierte C#-Funktion, die in einem Workerprozess ausgeführt wird, der von der Runtime isoliert ist. Ein isolierter Workerprozess ist erforderlich, um C#-Funktionen zu unterstützen, die in LTS- und Nicht-LTS-Versionen von .NET und .NET Framework ausgeführt werden.
• In-Process-Modell: Kompilierte C#-Funktion, die im gleichen Prozess wie die Functions-Runtime ausgeführt wird.
• C#-Skript: Wird hauptsächlich beim Erstellen von C#-Funktionen im Azure-Portal verwendet.

Wichtig

Die Unterstützung für das In-Process-Modell endet am 10. November 2026. Es wird dringend empfohlen, Ihre Apps zum isolierten Workermodell zu migrieren, um den vollständigen Support zu ermöglichen.

Isoliertes Workermodell

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben eines Datensatzes
• HTTP-Trigger: Schreiben in zwei Tabellen

Die Beispiele beziehen sich auf eine ToDoItem-Klasse und eine entsprechende Datenbanktabelle:

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

Um mehrere Ausgabebindungen in unseren Beispielen zurückzugeben, erstellen wir einen benutzerdefinierten Rückgabetyp:

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

HTTP-Trigger: Schreiben eines Datensatzes

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank einen Datensatz hinzufügt und dabei Daten aus einer HTTP POST-Anforderung als JSON-Textkörper verwendet. Das Rückgabeobjekt ist die OutputType-Klasse, die Sie erstellt haben, um eine HTTP-Antwort und die SQL-Ausgabebindung zu behandeln.

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: Schreiben in zwei Tabellen

Im folgenden Beispiel zeigt eine C#-Funktion, die Datensätze zu einer Datenbank in zwei verschiedenen Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt, indem Daten aus einer HTTP-POST-Anforderung als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet werden.

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

Um eine zusätzliche Ausgabebindung zu verwenden, fügen Sie eine Klasse für RequestLog hinzu und ändern die 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; }
    }

}

In-Process-Modell

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben eines Datensatzes
• HTTP-Trigger: Schreiben in zwei Tabellen
• HTTP-Trigger: Schreiben von Datensätzen mit IAsyncCollector

Die Beispiele beziehen sich auf eine ToDoItem-Klasse und eine entsprechende Datenbanktabelle:

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: Schreiben eines Datensatzes

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank einen Datensatz hinzufügt und dabei Daten aus einer HTTP POST-Anforderung als JSON-Textkörper verwendet.

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: Schreiben in zwei Tabellen

Im folgenden Beispiel zeigt eine C#-Funktion, die Datensätze zu einer Datenbank in zwei verschiedenen Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt, indem Daten aus einer HTTP-POST-Anforderung als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet werden.

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: Schreiben von Datensätzen mit IAsyncCollector

Das folgende Beispiel zeigt eine C#-Funktion, die einer Datenbank eine Sammlung von Datensätzen hinzufügt und dabei Daten aus einem JSON-Array im HTTP POST-Textkörper verwendet.

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

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben eines Datensatzes in eine Tabelle
• HTTP-Trigger: Schreiben in zwei Tabellen

Die Beispiele beziehen sich auf eine ToDoItem-Klasse (in einer getrennten Datei ToDoItem.java) und eine entsprechende Datenbanktabelle:

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: Schreiben eines Datensatzes in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in einer Java-Funktion, die einen Datensatz einer Tabelle hinzufügt und dabei Daten verwendet, die in einer HTTP POST-Anforderung als JSON-Textkörper bereitgestellt werden. Die Funktion verwendet eine zusätzliche Abhängigkeit von der com.google.code.gson-Bibliothek , um den JSON-Text zu analysieren.

<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: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in einer JavaS-Funktion, die Datensätze zu zwei unterschiedlichen Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet. Die Funktion verwendet eine zusätzliche Abhängigkeit von der com.google.code.gson-Bibliothek , um den JSON-Text zu analysieren.

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

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

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

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle
• HTTP-Trigger: Schreiben in zwei Tabellen

Das Beispiel bezieht sich auf eine Datenbanktabelle:

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: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung, die einer Tabelle Datensätze hinzufügt und dabei Daten verwendet, die in einer HTTP POST-Anforderung als JSON-Textkörper bereitgestellt werden.

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

Modell v3

TypeScript-Beispiele sind für Modell v3 nicht dokumentiert.

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

Modell v3

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Hier sehen Sie JavaScript-Beispielcode:

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: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung, die Datensätze zu zwei unterschiedlichen Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet.

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

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

Modell v3

TypeScript-Beispiele sind für Modell v3 nicht dokumentiert.

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

Modell v3

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Hier sehen Sie JavaScript-Beispielcode:

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

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle
• HTTP-Trigger: Schreiben in zwei Tabellen

Das Beispiel bezieht sich auf eine Datenbanktabelle:

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: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine PowerShell-Funktion, die Datensätze einer Tabelle hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper verwendet.

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Es folgt ein PowerShell-Beispielcode für die Funktion in der Datei 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
})

HTTP-Trigger: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine PowerShell-Funktion, die Datensätze zwei Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet.

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Es folgt ein PowerShell-Beispielcode für die Funktion in der Datei 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
})

Weitere Beispiele für die Azure SQL-Ausgabebindung sind im GitHub-Repository verfügbar.

Dieser Abschnitt enthält folgende Beispiele:

• HTTP-Trigger: Schreiben von Datensätzen in eine Tabelle
• HTTP-Trigger: Schreiben in zwei Tabellen

Das Beispiel bezieht sich auf eine Datenbanktabelle:

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: Schreiben von Datensätzen in eine Tabelle

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine Python-Funktion, die Datensätze einer Tabelle hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper verwendet.

v2

Nachfolgend sehen Sie Python-Beispielcode für die function_app.py-Datei:

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

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Hier sehen Sie Python-Beispielcode:

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: Schreiben in zwei Tabellen

Das folgende Beispiel zeigt eine SQL-Ausgabebindung in der Datei „function.json“ und eine Python-Funktion, die Datensätze zu zwei Tabellen (dbo.ToDo und dbo.RequestLog) hinzufügt. Dabei werden in einer HTTP POST-Anforderung bereitgestellte Daten als JSON-Textkörper sowie mehrere Ausgabebindungen verwendet.

Die zweite Tabelle, dbo.RequestLog, entspricht der folgenden Definition:

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

v2

Nachfolgend sehen Sie Python-Beispielcode für die function_app.py-Datei:

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

Das folgende Beispiel bindet Daten in der function.json-Datei:

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

Weitere Informationen zu diesen Eigenschaften finden Sie im Abschnitt Konfiguration.

Hier sehen Sie Python-Beispielcode:

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
        )

Attribute

Die C#-Bibliothek verwendet das Attribut SqlAttribute, um die SQL-Bindungen für die Funktion zu deklarieren, die die folgenden Eigenschaften hat:

Attributeigenschaft	BESCHREIBUNG
CommandText	Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
ConnectionStringSetting	Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dies ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen auf eine Umgebungsvariable aufgelöst werden.

Anmerkungen

Verwenden Sie in der Laufzeitbibliothek für Java-Funktionen die Anmerkung @SQLOutput (com.microsoft.azure.functions.sql.annotation.SQLOutput) für Parameter, deren Wert aus Azure SQL stammt. Diese Anmerkung unterstützt die folgenden Elemente:

Element	BESCHREIBUNG
commandText	Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
connectionStringSetting	Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dies ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen auf eine Umgebungsvariable aufgelöst werden.
name	Erforderlich. Der eindeutige Name der Funktionsbindung.

Konfiguration

Modell v4

In der folgenden Tabelle werden die Eigenschaften erläutert, die Sie für das options-Objekt festlegen können, das an die output.sql()-Methode übergeben wurde.

Eigenschaft	Beschreibung
commandText	Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
connectionStringSetting	Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dies ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen auf eine Umgebungsvariable aufgelöst werden. Optionale Schlüsselwörter im Verbindungszeichenfolgewert sind verfügbar, um die SQL-Bindungskonnektivität zu verfeinern.

Modell v3

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json festlegen.

Eigenschaft	Beschreibung des Dataflows
type	Erforderlich. Muss auf sql festgelegt sein.
direction	Erforderlich. Muss auf out festgelegt sein.
name	Erforderlich. Der Name der Variablen, die die Entität im Funktionscode darstellt.
commandText	Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
connectionStringSetting	Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dies ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen auf eine Umgebungsvariable aufgelöst werden. Optionale Schlüsselwörter im Verbindungszeichenfolgewert sind verfügbar, um die SQL-Bindungskonnektivität zu verfeinern.

Konfiguration

Die folgende Tabelle gibt Aufschluss über die Bindungskonfigurationseigenschaften, die Sie in der Datei function.json festlegen.

function.json-Eigenschaft	BESCHREIBUNG
type	Erforderlich. Muss auf sql festgelegt sein.
direction	Erforderlich. Muss auf out festgelegt sein.
name	Erforderlich. Der Name der Variablen, die die Entität im Funktionscode darstellt.
commandText	Erforderlich. Der Name der Tabelle, in die die Bindung geschrieben wird.
connectionStringSetting	Erforderlich. Der Name einer App-Einstellung, die die Verbindungszeichenfolge für die Datenbank enthält, in die Daten geschrieben werden. Dies ist nicht die tatsächliche Verbindungszeichenfolge und muss stattdessen auf eine Umgebungsvariable aufgelöst werden. Optionale Schlüsselwörter im Verbindungszeichenfolgewert sind verfügbar, um die SQL-Bindungskonnektivität zu verfeinern.

Wenn Sie die Entwicklung lokal ausführen, fügen Sie Ihre Anwendungseinstellungen in der Datei local.settings.json in der Values-Sammlung hinzu.

Verwendung

Die CommandText-Eigenschaft ist der Name der Tabelle, in der die Daten gespeichert werden sollen. Der Name der Verbindungszeichenfolgeneinstellung entspricht der Anwendungseinstellung, die die Verbindungszeichenfolge für die Azure SQL- oder SQL Server-Instanz enthält.

Die Ausgabebindungen verwenden die T-SQL-Anweisung MERGE, die SELECT-Berechtigungen für die Zieldatenbank erfordert.

Wenn beim Ausführen einer SQL-Ausgabebindung eine Ausnahme auftritt, wird der Funktionscode nicht weiter ausgeführt. Das kann dazu führen, dass ein Fehlercode zurückgegeben wird, z. B. ein HTTP-Trigger, der einen Fehlercode 500 zurückgibt. Wenn der IAsyncCollector einer .NET-Funktion verwendet wird, kann der Funktionscode Ausnahmen behandeln, die durch den Aufruf von FlushAsync() ausgelöst werden.

Nächste Schritte

• Lesen von Daten aus einer Datenbank (Eingabebindung)
• Ausführen einer Funktion bei Datenänderungen in einer SQL-Tabelle (Trigger)
• Überprüfen Sie das ToDo API-Beispiel mit Azure SQL-Bindungen