Azure SQL kimeneti kötés az Azure Functionshez

Az Azure SQL kimeneti kötése lehetővé teszi az adatbázisba való írást.

A beállítással és a konfigurációval kapcsolatos információkért tekintse meg az áttekintést.

Fontos

Ez a cikk lapokat használ a Node.js programozási modell több verziójának támogatásához. A v4-modell általánosan elérhető, és úgy lett kialakítva, hogy rugalmasabb és intuitívabb felhasználói élményt nyújtson JavaScript- és TypeScript-fejlesztők számára. A v4-modell működésével kapcsolatos további információkért tekintse meg az Azure Functions Node.js fejlesztői útmutatóját. A v3 és a v4 közötti különbségekről a migrálási útmutatóban olvashat bővebben.

Példák

A C#-függvények a következő C#-módok egyikével hozhatók létre:

• Izolált feldolgozómodell: Lefordított C# függvény, amely a futtatókörnyezettől elkülönített feldolgozói folyamatban fut. Izolált feldolgozói folyamat szükséges az LTS- és nem LTS-verziókon futó C#-függvények támogatásához .NET és .NET-keretrendszer.
• Folyamaton belüli modell: Lefordított C# függvény, amely ugyanabban a folyamatban fut, mint a Functions-futtatókörnyezet.
• C#-szkript: Elsősorban C#-függvények Azure Portalon való létrehozásakor használatos.

Fontos

A folyamaton belüli modell támogatása 2026. november 10-én megszűnik. Erősen javasoljuk, hogy az alkalmazásokat az elkülönített feldolgozói modellbe migrálja a teljes támogatás érdekében.

Izolált feldolgozói modell

Az Azure SQL kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, egy rekord írása
• HTTP-eseményindító, írás két táblába

A példák egy ToDoItem osztályra és egy megfelelő adatbázistáblára vonatkoznak:

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

Ha több kimeneti kötést szeretne visszaadni a mintánkban, létrehozunk egy egyéni visszatérési típust:

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

HTTP-eseményindító, egy rekord írása

Az alábbi példa egy C# függvényt mutat be, amely egy rekordot ad hozzá egy adatbázishoz egy HTTP POST-kérelemben JSON-törzsként megadott adatok használatával. A visszatérési objektum az az OutputType osztály, amelyet a HTTP-válasz és az SQL kimeneti kötés kezelésére hoztunk létre.

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-eseményindító, írás két táblába

Az alábbi példa egy C# függvényt mutat be, amely két különböző táblában (dbo.ToDo és ) a HTTP POST-kérelemben megadott adatokat JSON-törzsként és dbo.RequestLogtöbb kimeneti kötésként adja hozzá egy adatbázishoz.

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

További kimeneti kötés használatához hozzáadunk egy osztályt, és módosítjuk az RequestLog osztályt 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; }
    }

}

Folyamaton belüli modell

Az Azure SQL kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, egy rekord írása
• HTTP-eseményindító, írás két táblába
• HTTP-eseményindító, rekordok írása az IAsyncCollector használatával

A példák egy ToDoItem osztályra és egy megfelelő adatbázistáblára vonatkoznak:

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-eseményindító, egy rekord írása

Az alábbi példa egy C# függvényt mutat be, amely egy rekordot ad hozzá egy adatbázishoz egy HTTP POST-kérelemben JSON-törzsként megadott adatok használatával.

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-eseményindító, írás két táblába

Az alábbi példa egy C# függvényt mutat be, amely két különböző táblában (dbo.ToDo és ) a HTTP POST-kérelemben megadott adatokat JSON-törzsként és dbo.RequestLogtöbb kimeneti kötésként adja hozzá egy adatbázishoz.

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-eseményindító, rekordok írása az IAsyncCollector használatával

Az alábbi példa egy C# függvényt mutat be, amely rekordgyűjteményt ad hozzá egy adatbázishoz egy HTTP POST törzs JSON-tömbben megadott adatok használatával.

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

Az Azure SQL kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, rekord írása egy táblába
• HTTP-eseményindító, írás két táblába

A példák egy ToDoItem osztályra (külön fájlban ToDoItem.java) és egy megfelelő adatbázistáblára vonatkoznak:

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-eseményindító, rekord írása egy táblába

Az alábbi példa egy OLYAN SQL-kimeneti kötést mutat be egy Java-függvényben, amely egy rekordot ad hozzá egy táblához egy HTTP POST-kérelemben JSON-törzsként megadott adatok használatával. A függvény további függőséget vesz fel a com.google.code.gson kódtártól a JSON-törzs elemzéséhez.

<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-eseményindító, írás két táblába

Az alábbi példa egy OLYAN SQL-kimeneti kötést mutat be egy JavaS-függvényben, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (dbo.ToDo és dbo.RequestLog), amelyek egy HTTP POST-kérelemben megadott adatokat használnak JSON-törzsként és több kimeneti kötésként. A függvény további függőséget vesz fel a com.google.code.gson kódtártól a JSON-törzs elemzéséhez.

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

A második tábla dbo.RequestLoga következő definíciónak felel meg:

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

és Java-osztály a következőben 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();
    }
}

Az Azure SQL kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, rekordok írása egy táblába
• HTTP-eseményindító, írás két táblába

A példák egy adatbázistáblára vonatkoznak:

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-eseményindító, rekordok írása egy táblába

Az alábbi példa egy SQL-kimeneti kötést mutat be, amely rekordokat ad hozzá egy táblához egy HTTP POST-kérelemben JSON-törzsként megadott adatok használatával.

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

A TypeScript-minták nincsenek dokumentálva a v3-as modellhez.

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

A következő kötési adatok a function.json fájlban:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő javaScript-mintakó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
    }
}

HTTP-eseményindító, írás két táblába

Az alábbi példa egy SQL kimeneti kötést mutat be, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (dbo.ToDo és dbo.RequestLog), amelyek egy HTTP POST-kérelemben megadott adatokat használnak JSON-törzsként és több kimeneti kötésként.

A második tábla dbo.RequestLoga következő definíciónak felel meg:

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

A TypeScript-minták nincsenek dokumentálva a v3-as modellhez.

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

A következő kötési adatok a function.json fájlban:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő javaScript-mintakó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
    }
}

Az Azure SQL kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, rekordok írása egy táblába
• HTTP-eseményindító, írás két táblába

A példák egy adatbázistáblára vonatkoznak:

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-eseményindító, rekordok írása egy táblába

Az alábbi példa egy SQL-kimeneti kötést mutat be egy function.json fájlban, valamint egy PowerShell-függvényt, amely rekordokat ad hozzá egy táblához a HTTP POST-kérelemben JSON-törzsként megadott adatok használatával.

A következő kötési adatok a function.json fájlban:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A fájlban található függvény powerShell-kódjának mintája a run.ps1 következő:

```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-eseményindító, írás két táblába

Az alábbi példa egy SQL-kimeneti kötést mutat be egy function.json fájlban, valamint egy PowerShell-függvényt, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (dbo.ToDo és dbo.RequestLog), amelyek egy HTTP POST-kérelemben megadott adatokat használnak JSON-törzsként és több kimeneti kötésként.

A második tábla dbo.RequestLoga következő definíciónak felel meg:

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

A következő kötési adatok a function.json fájlban:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A fájlban található függvény powerShell-kódjának mintája a run.ps1 következő:

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

Az Azure SQL kimeneti kötéséhez további minták érhetők el a GitHub-adattárban.

Ez a szakasz a következő példákat tartalmazza:

• HTTP-eseményindító, rekordok írása egy táblába
• HTTP-eseményindító, írás két táblába

A példák egy adatbázistáblára vonatkoznak:

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-eseményindító, rekordok írása egy táblába

Az alábbi példa egy SQL-kimeneti kötést mutat be egy function.json fájlban, valamint egy Python-függvényt, amely rekordokat ad hozzá egy táblához a HTTP POST-kérelemben JSON-törzsként megadott adatok használatával.

A következő kötési adatok a function.json fájlban:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő python-mintakód:

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-eseményindító, írás két táblába

Az alábbi példa egy SQL-kimeneti kötést mutat be egy function.json fájlban és egy Python-függvényben, amely rekordokat ad hozzá egy adatbázishoz két különböző táblában (dbo.ToDo és dbo.RequestLog), amelyek egy HTTP POST-kérelemben megadott adatokat használnak JSON-törzsként és több kimeneti kötésként.

A második tábla dbo.RequestLoga következő definíciónak felel meg:

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

A következő kötési adatok a function.json fájlban:

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

A konfigurációs szakasz ezeket a tulajdonságokat ismerteti.

A következő python-mintakód:

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
        )

Attribútumok

A C#-kódtár az SqlAttribute attribútummal deklarálja az SQL-kötéseket a függvényen, amely a következő tulajdonságokkal rendelkezik:

Attribútumtulajdonság	Leírás
CommandText	Szükséges. A kötés által írt tábla neve.
Csatlakozás ionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelybe az adatok írása folyamatban van. Ez nem a tényleges kapcsolati sztring, hanem egy környezeti változóra kell feloldani.

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában használja a széljegyzetet (com.microsoft.azure.functions.sql.annotation.SQLOutput) azon @SQLOutput paramétereken, amelyek értéke az Azure SQL-ből származna. Ez a széljegyzet a következő elemeket támogatja:

Elem	Leírás
commandText	Szükséges. A kötés által írt tábla neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelybe az adatok írása folyamatban van. Ez nem a tényleges kapcsolati sztring, hanem egy környezeti változóra kell feloldani.
név	Szükséges. A függvénykötés egyedi neve.

Konfiguráció

Modell v4

Az alábbi táblázat a metódusnak output.sql() átadott objektumon options beállítható tulajdonságokat ismerteti.

Tulajdonság	Leírás
commandText	Szükséges. A kötés által írt tábla neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelybe az adatok írása folyamatban van. Ez nem a tényleges kapcsolati sztring, hanem egy környezeti változóra kell feloldani. A kapcsolati sztring érték választható kulcsszavai az SQL-kötések kapcsolatának finomításához érhetők el.

Modell v3

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

Tulajdonság	Leírás
type	Szükséges. A beállításnak a sqlkövetkezőnek kell lennie: .
direction	Szükséges. A beállításnak a outkövetkezőnek kell lennie: .
név	Szükséges. Annak a változónak a neve, amely az entitást jelöli a függvénykódban.
commandText	Szükséges. A kötés által írt tábla neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelybe az adatok írása folyamatban van. Ez nem a tényleges kapcsolati sztring, hanem egy környezeti változóra kell feloldani. A kapcsolati sztring érték választható kulcsszavai az SQL-kötések kapcsolatának finomításához érhetők el.

Konfiguráció

Az alábbi táblázat a function.json fájlban beállított kötéskonfigurációs tulajdonságokat ismerteti.

function.json tulajdonság	Leírás
type	Szükséges. A beállításnak a sqlkövetkezőnek kell lennie: .
direction	Szükséges. A beállításnak a outkövetkezőnek kell lennie: .
név	Szükséges. Annak a változónak a neve, amely az entitást jelöli a függvénykódban.
commandText	Szükséges. A kötés által írt tábla neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelybe az adatok írása folyamatban van. Ez nem a tényleges kapcsolati sztring, hanem egy környezeti változóra kell feloldani. A kapcsolati sztring érték választható kulcsszavai az SQL-kötések kapcsolatának finomításához érhetők el.

Helyi fejlesztéskor adja hozzá az alkalmazásbeállításokat a gyűjtemény local.settings.json fájljáhozValues.

Használat

A CommandText tulajdonság annak a táblának a neve, amelyben az adatokat tárolni szeretné. A kapcsolati sztring beállítás neve az Azure SQL- vagy SQL Server-példány kapcsolati sztring tartalmazó alkalmazásbeállításnak felel meg.

A kimeneti kötések a T-SQL MERGE utasítást használják, amelyhez Standard kiadás LECT-engedélyek szükségesek a céladatbázison.

Ha kivétel történik egy SQL-kimeneti kötés végrehajtásakor, akkor a függvénykód leállítja a végrehajtást. Ez egy hibakód visszaadását eredményezheti, például egy 500-as hibakódot visszaadó HTTP-eseményindítót. Ha a függvényt IAsyncCollector .NET-függvényben használják, a függvénykód képes kezelni a hívás által a következőre FlushAsync()irányuló kivételeket.

Következő lépések

• Adatok beolvasása adatbázisból (bemeneti kötés)
• Függvény futtatása sql-táblában (trigger) lévő adatok módosításakor
• ToDo API-minta áttekintése Azure SQL-kötésekkel