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.

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

Dieser Abschnitt enthält folgende Beispiele:

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

}

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

Dieser Abschnitt enthält folgende Beispiele:

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:

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.

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

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

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

Dieser Abschnitt enthält folgende Beispiele:

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:

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.

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

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
)

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
        )

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

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.

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