Výstupní vazba Azure SQL pro Azure Functions

Výstupní vazba Azure SQL umožňuje zapisovat do databáze.

Informace o nastavení a konfiguraci najdete v přehledu.

Důležité

Tento článek používá karty pro podporu více verzí programovacího modelu Node.js. Model v4 je obecně dostupný a je navržený tak, aby měl flexibilnější a intuitivnější prostředí pro vývojáře v JavaScriptu a TypeScriptu. Další podrobnosti o tom, jak model v4 funguje, najdete v příručce pro vývojáře služby Azure Functions Node.js. Další informace o rozdílech mezi v3 a v4 najdete v průvodci migrací.

Úplný kompletní příklad použití výstupní vazby Azure SQL najdete v tématu Zodpovězte Azure SQL Database změn pomocí Azure Functions.

Příklady

Podpora Go pro toto vázání momentálně není dostupná.

Funkci jazyka C# můžete vytvořit pomocí jednoho z následujících režimů jazyka C#:

• Izolovaný model pracovního procesu: Kompilovaná funkce jazyka C#, která běží v pracovním procesu, který je izolovaný od modulu runtime. Izolovaný pracovní proces se vyžaduje pro podporu funkcí jazyka C# běžících na dlouhodobé podpoře (LTS) a jiných verzích než LTS pro .NET a rozhraní .NET Framework.
• Model v procesu: Zkompilovaná funkce jazyka C#, která běží ve stejném procesu jako modul runtime Azure Functions.
• Skript jazyka C#: Používá se především při vytváření funkcí jazyka C# na webu Azure Portal.

Důležité

Podpora modelu v procesu skončí 10. listopadu 2026. Důrazně doporučujeme migrovat aplikace do izolovaného modelu pracovního procesu pro plnou podporu.

Izolovaný model pracovního procesu

Další ukázky pro výstupní vazbu Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis jednoho záznamu
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na ToDoItem třídu a odpovídající tabulku databáze:

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

Abychom v našich ukázkách vrátili více výstupních vazeb , vytvoříme vlastní návratový typ:

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

Trigger HTTP, zápis jednoho záznamu

Následující příklad ukazuje funkci jazyka C#, která přidá záznam do databáze pomocí dat zadaných v požadavku HTTP POST jako textu JSON. Návratový objekt je OutputType třída, kterou jsme vytvořili pro zpracování odpovědi HTTP i výstupní vazby SQL.

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            var logger = executionContext.GetLogger("PostToDo");
            logger.LogInformation("C# HTTP trigger function processed a request.");

            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            return new OutputType()
            {
                ToDoItem = toDoItem,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

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

        public HttpResponseData HttpResponse { get; set; }
    }
}

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje funkci jazyka vazeb.

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

Abychom mohli použít další výstupní vazbu, přidáme třídu pro RequestLog naši třídu a upravíme ji OutputType :

using System;
using System.Collections.Generic;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Http;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;

namespace AzureSQL.ToDo
{
    public static class PostToDo
    {
        // create a new ToDoItem from body object
        // uses output binding to insert new item into ToDo table
        [FunctionName("PostToDo")]
        public static async Task<OutputType> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "PostFunction")] HttpRequestData req,
                FunctionContext executionContext)
        {
            string requestBody = await new StreamReader(req.Body).ReadToEndAsync();
            ToDoItem toDoItem = JsonConvert.DeserializeObject<ToDoItem>(requestBody);

            // generate a new id for the todo item
            toDoItem.Id = Guid.NewGuid();

            // set Url from env variable ToDoUri
            toDoItem.url = Environment.GetEnvironmentVariable("ToDoUri")+"?id="+toDoItem.Id.ToString();

            // if completed is not provided, default to false
            if (toDoItem.completed == null)
            {
                toDoItem.completed = false;
            }

            requestLog = new RequestLog();
            requestLog.RequestTimeStamp = DateTime.Now;
            requestLog.ItemCount = 1;

            return new OutputType()
            {
                ToDoItem = toDoItem,
                RequestLog = requestLog,
                HttpResponse = req.CreateResponse(System.Net.HttpStatusCode.Created)
            }
        }
    }

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

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

        [SqlOutput("dbo.RequestLog", connectionStringSetting: "SqlConnectionString")]
        public RequestLog RequestLog { get; set; }

        public HttpResponseData HttpResponse { get; set; }
    }

}

Model v procesu

Další ukázky pro výstupní vazbu Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis jednoho záznamu
• Trigger HTTP, zápis do dvou tabulek
• Trigger HTTP, zápis záznamů pomocí IAsyncCollectoru

Příklady odkazují na ToDoItem třídu a odpovídající tabulku databáze:

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

Trigger HTTP, zápis jednoho záznamu

Následující příklad ukazuje funkci jazyka C#, která přidá záznam do databáze pomocí dat zadaných v požadavku HTTP POST jako textu JSON.

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

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje funkci jazyka vazeb.

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

Trigger HTTP, zápis záznamů pomocí IAsyncCollectoru

Následující příklad ukazuje funkci jazyka C#, která přidá kolekci záznamů do databáze pomocí dat zadaných v poli JSON textu HTTP POST.

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

Další ukázky pro výstupní vazbu Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis záznamu do tabulky
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na ToDoItem třídu (v samostatném souboru ToDoItem.java) a odpovídající tabulku databáze:

package com.function;
import java.util.UUID;

public class ToDoItem {
    public UUID Id;
    public int order;
    public String title;
    public String url;
    public boolean completed;

    public ToDoItem() {
    }

    public ToDoItem(UUID Id, int order, String title, String url, boolean completed) {
        this.Id = Id;
        this.order = order;
        this.title = title;
        this.url = url;
        this.completed = completed;
    }
}

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Trigger HTTP, zápis záznamu do tabulky

Následující příklad ukazuje výstupní vazbu SQL ve funkci Java, která přidá záznam do tabulky pomocí dat zadaných v požadavku HTTP POST jako tělo JSON. Funkce přebírá další závislost na knihovně com.google.code.gson k analýze textu JSON.

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

package com.function;

import java.util.*;
import com.microsoft.azure.functions.annotation.*;
import com.microsoft.azure.functions.*;
import com.microsoft.azure.functions.sql.annotation.SQLOutput;
import com.google.gson.Gson;

import java.util.Optional;

public class PostToDo {
    @FunctionName("PostToDo")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output) {
        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);

        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

        return request.createResponseBuilder(HttpStatus.CREATED).header("Content-Type", "application/json").body(output).build();
    }
}

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu SQL ve funkci JavaS, která přidává záznamy do databáze ve dvou různých tabulkách (dbo.ToDo a dbo.RequestLog) pomocí dat zadaných v požadavku HTTP POST jako tělo JSON a několik výstupních vazeb. Funkce přebírá další závislost na knihovně com.google.code.gson k analýze textu JSON.

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

Druhá tabulka, dbo.RequestLogodpovídá následující definici:

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

a třída Java v 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();
    }
}

Další ukázky pro výstupní vazbu Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis záznamů do tabulky
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na tabulku databáze:

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Trigger HTTP, zápis záznamů do tabulky

Následující příklad ukazuje výstupní vazbu SQL, která přidává záznamy do tabulky pomocí dat zadaných v požadavku HTTP POST jako tělo JSON.

Model v4

Model v3

Ukázky TypeScriptu nejsou zdokumentované pro model v3.

Model v4

Model v3

V souboru function.json jsou svázná data:

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

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následuje ukázkový javascriptový kód:

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

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu SQL, která přidává záznamy do databáze ve dvou různých tabulkách (dbo.ToDo a dbo.RequestLog) pomocí dat poskytovaných v požadavku HTTP POST jako tělo JSON a více výstupních vazeb.

Druhá tabulka, dbo.RequestLogodpovídá následující definici:

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

Model v4

Model v3

Ukázky TypeScriptu nejsou zdokumentované pro model v3.

Model v4

Model v3

V souboru function.json jsou svázná data:

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

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následuje ukázkový javascriptový kód:

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

Další ukázky pro výstupní vazbu Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis záznamů do tabulky
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na tabulku databáze:

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Trigger HTTP, zápis záznamů do tabulky

Následující příklad ukazuje výstupní vazbu SQL v souboru function.json a funkci PowerShellu, která přidává záznamy do tabulky pomocí dat zadaných v požadavku HTTP POST jako tělo JSON.

V souboru function.json jsou svázná data:

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

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následuje ukázkový kód PowerShellu pro funkci v run.ps1 souboru:

```powershell
using namespace System.Net

param($Request)

Write-Host "PowerShell function with SQL Output Binding processed a request."

# Update req_body with the body of the request
$req_body = $Request.Body

# Assign the value we want to pass to the SQL Output binding. 
# The -Name value corresponds to the name property in the function.json for the binding
Push-OutputBinding -Name todoItems -Value $req_body

Push-OutputBinding -Name res -Value ([HttpResponseContext]@{
    StatusCode = [HttpStatusCode]::OK
    Body = $req_body
})

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu SQL v souboru function.json a funkci PowerShellu, která přidává záznamy do databáze ve dvou různých tabulkách (dbo.ToDo a dbo.RequestLog) pomocí dat zadaných v požadavku HTTP POST jako tělo JSON a několik výstupních vazeb.

Druhá tabulka, dbo.RequestLogodpovídá následující definici:

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

V souboru function.json jsou svázná data:

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

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následuje ukázkový kód PowerShellu pro funkci v run.ps1 souboru:

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

Další ukázky pro výstupní vazbu Azure SQL jsou k dispozici v úložišti GitHub.

Tato část obsahuje následující příklady:

• Trigger HTTP, zápis záznamů do tabulky
• Trigger HTTP, zápis do dvou tabulek

Příklady odkazují na tabulku databáze:

CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

Trigger HTTP, zápis záznamů do tabulky

Následující příklad ukazuje výstupní vazbu SQL v souboru function.json a funkci Pythonu, která přidává záznamy do tabulky pomocí dat zadaných v požadavku HTTP POST jako tělo JSON.

v2

Následuje ukázkový kód Pythonu pro soubor function_app.py:

import json
import logging
import azure.functions as func

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

V souboru function.json jsou svázná data:

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

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následuje ukázkový kód Pythonu:

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
        )

Trigger HTTP, zápis do dvou tabulek

Následující příklad ukazuje výstupní vazbu SQL v souboru function.json a funkci Pythonu, která přidává záznamy do databáze ve dvou různých tabulkách (dbo.ToDo a dbo.RequestLog) pomocí dat zadaných v požadavku HTTP POST jako textu JSON a několika výstupních vazeb.

Druhá tabulka, dbo.RequestLogodpovídá následující definici:

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

v2

Následuje ukázkový kód Pythonu pro soubor function_app.py:

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

app = func.FunctionApp()

@app.function_name(name="PostToDo")
@app.route(route="posttodo")
@app.sql_output(arg_name="todoItems",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
@app.sql_output(arg_name="requestLog",
                        command_text="[dbo].[RequestLog]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todoItems: func.Out[func.SqlRow], requestLog: func.Out[func.SqlRow]) -> func.HttpResponse:
    logging.info('Python HTTP trigger and SQL output binding function processed a request.')
    try:
        req_body = req.get_json()
        rows = func.SqlRowList(map(lambda r: func.SqlRow.from_dict(r), req_body))
    except ValueError:
        pass

    requestLog.set(func.SqlRow({
        "RequestTimeStamp": datetime.now().isoformat(),
        "ItemCount": 1
    }))

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

v1

V souboru function.json jsou svázná data:

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

Oddíl konfigurace vysvětluje tyto vlastnosti.

Následuje ukázkový kód Pythonu:

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
        )

Atributy

Knihovna jazyka C# pomocí atributu SqlAttribute deklaruje vazby SQL funkce, která má následující vlastnosti:

Vlastnost atributu	Popis
CommandText	Povinný: Název tabulky, do které se zapisuje vazba.
ConnectionStringSetting	Povinný: Název nastavení aplikace, které obsahuje připojovací řetězec databáze, do které se data zapisují. Tato hodnota není skutečným připojovacím řetězcem a musí se místo toho přeložit na proměnnou prostředí.

Poznámky

V knihovně modulu runtime funkcí Java použijte @SQLOutput anotaci (com.microsoft.azure.functions.sql.annotation.SQLOutput) u parametrů, jejichž hodnota pochází z Azure SQL. Tato poznámka podporuje následující prvky:

Element (Prvek)	Popis
commandText	Povinný: Název tabulky, do které se zapisuje vazba.
connectionStringSetting	Povinný: Název nastavení aplikace, které obsahuje připojovací řetězec databáze, do které se data zapisují. Tato hodnota není skutečným připojovacím řetězcem a musí se místo toho přeložit na proměnnou prostředí.
Jméno	Povinný: Jedinečný název vazby funkce.

Konfigurace

Model v4

Následující tabulka vysvětluje vlastnosti, které můžete nastavit u objektu předaného options metodě output.sql() .

Vlastnost	Popis
commandText	Povinný: Název tabulky, do které se zapisuje vazba.
connectionStringSetting	Povinný: Název nastavení aplikace, které obsahuje připojovací řetězec databáze, do které se data zapisují. Tato hodnota není skutečným připojovacím řetězcem a musí se místo toho přeložit na proměnnou prostředí. Volitelná klíčová slova v hodnotě připojovací řetězec jsou k dispozici pro upřesnění připojení vazeb SQL.

Model v3

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

Vlastnost	Popis
typ	Povinný: Musí být nastavena na sqlhodnotu .
směr	Povinný: Musí být nastavena na outhodnotu .
Jméno	Povinný: Název proměnné, která představuje entitu v kódu funkce.
commandText	Povinný: Název tabulky, do které se zapisuje vazba.
connectionStringSetting	Povinný: Název nastavení aplikace, které obsahuje připojovací řetězec databáze, do které se data zapisují. Tato hodnota není skutečným připojovacím řetězcem a musí se místo toho přeložit na proměnnou prostředí. Volitelná klíčová slova v hodnotě připojovací řetězec jsou k dispozici pro upřesnění připojení vazeb SQL.

Konfigurace

Následující tabulka vysvětluje vlastnosti konfigurace vazby, které jste nastavili v souboru function.json .

vlastnost function.json	Popis
typ	Povinný: Musí být nastavena na sqlhodnotu .
směr	Povinný: Musí být nastavena na outhodnotu .
Jméno	Povinný: Název proměnné, která představuje entitu v kódu funkce.
commandText	Povinný: Název tabulky, do které se zapisuje vazba.
connectionStringSetting	Povinný: Název nastavení aplikace, které obsahuje připojovací řetězec databáze, do které se data zapisují. Tato hodnota není skutečným připojovacím řetězcem a musí se místo toho přeložit na proměnnou prostředí. Volitelná klíčová slova v hodnotě připojovací řetězec jsou k dispozici pro upřesnění připojení vazeb SQL.

Při místním vývoji přidejte nastavení aplikace do souboru local.settings.json v kolekci Values .

Využití

Vlastnost CommandText je název tabulky, ve které se mají data ukládat.

Výstupní vazby používají příkaz T-SQL MERGE , který vyžaduje oprávnění SELECT pro cílovou databázi.

Pokud při spuštění výstupní vazby SQL dojde k výjimce, kód funkce se zastaví. Toto chování může mít za následek vrácení kódu chyby, například trigger HTTP vracející kód chyby 500. IAsyncCollector Pokud se použije ve funkci .NET, kód funkce může zpracovat výjimky vyvolané voláním FlushAsync().

Connections

Vlastnost connectionStringSetting je nastavena na klíč v nastavení aplikace, který vrací hodnotu používanou runtime Functions k připojení k databázi Azure SQL nebo SQL Server používané rozšířením. Hodnota nastavení vlastnosti spojení závisí na typu spojení:

• Spravované identity connection: Vlastnost connectionStringSetting vrací připojovací řetězec, který používá Authentication=služba Active Directory Managed Identity autentizaci bez tajemství. Můžete použít spravovanou identitu přiřazenou systémem nebo spravovanou identitu přiřazenou uživatelem. Pro více informací viz Připojit funkční aplikaci k Azure SQL s řízenou identitou a Definovat spojení identity.
• Key Vault reference: Nastavení connectionStringSetting vlastnosti vrací Azure Key Vault reference na místo, kde je připojovací řetězec centrálně udržován. Pro více informací viz Definujte spojení Key Vault.
• App Configuration reference: Nastavení connectionStringSetting vlastnosti vrací referenci Azure App Configuration, která vrací připojovací řetězec nebo Key Vault reference. Pro více informací viz Azure App Configuration v článku o připojeních.
• Connection string: Nastavení connectionStringSetting vlastnosti vrací skutečný SQL připojovací řetězec. Protože připojovací řetězec může obsahovat přihlašovací údaje, měli byste použít managed identity connection nebo alespoň uložit připojovací řetězec v Key Vault. Pro více informací viz Definujte souvislosti.

Chcete-li se dozvědět více o vazbách spojení, viz Správa spojení v Azure Functions.

připojovací řetězec je předán Microsoftu. Data.SqlClient a podporuje všechna klíčová slova definovaná v dokumentaci SqlClient ConnectionString. Mezi klíčová slova patří:

• Authentication: Connect to Azure SQL with Microsoft Entra ID. Nastaveno na služba Active Directory Managed Identity pro spravované identity. Pro více informací viz Připojit funkční aplikaci k Azure SQL pomocí spravované identity.
• Command Timeout: Čekejte stanovený čas v několika sekundách před ukončením dotazu (výchozí 30 sekund).
• ConnectRetryCount: Automaticky provádět další pokusy o opětovné připojení, zejména pro serverless úroveň Azure SQL Database (výchozí 1).
• Pooling: Opětovné použití spojení s databází pro zlepšení výkonu (výchozí true). Mezi další nastavení sdružování připojení patří Connection Lifetime, Max Pool Sizea Min Pool Size. Více informací najdete v dokumentaci ADO.NET.

Další kroky

• Čtení dat z databáze (vstupní vazba)
• Spuštění funkce při změně dat v tabulce SQL (trigger)
• Kontrola ukázky rozhraní TODo API s využitím vazeb Azure SQL