Udostępnij za pośrednictwem

Powiązanie danych wyjściowych usługi Azure SQL dla usługi Azure Functions

  • Artykuł

Powiązanie danych wyjściowych usługi Azure SQL umożliwia zapisywanie w bazie danych.

Aby uzyskać informacje na temat konfiguracji i konfiguracji, zobacz omówienie.

Ważne

W tym artykule są używane karty do obsługi wielu wersji modelu programowania Node.js. Model w wersji 4 jest ogólnie dostępny i ma bardziej elastyczne i intuicyjne środowisko dla deweloperów języka JavaScript i Języka TypeScript. Aby uzyskać więcej informacji na temat sposobu działania modelu w wersji 4, zapoznaj się z przewodnikiem dewelopera dotyczącym usługi Azure Functions Node.js. Aby dowiedzieć się więcej o różnicach między wersjami 3 i v4, zapoznaj się z przewodnikiem migracji.

Przykłady

Funkcję języka C# można utworzyć przy użyciu jednego z następujących trybów języka C#:

  • Model izolowanego procesu roboczego: skompilowana funkcja języka C#, która jest uruchamiana w procesie roboczym izolowanym od środowiska uruchomieniowego. Proces izolowanego procesu roboczego jest wymagany do obsługi funkcji języka C# uruchomionych w wersjach LTS i innych niż LTS platformy .NET oraz programu .NET Framework.
  • Model przetwarzania: skompilowana funkcja języka C#, która działa w tym samym procesie co środowisko uruchomieniowe usługi Functions.
  • Skrypt języka C#: używany głównie podczas tworzenia funkcji języka C# w witrynie Azure Portal.

Ważne

Wsparcie zostanie zakończone dla modelu procesu 10 listopada 2026 r. Zdecydowanie zalecamy przeprowadzenie migracji aplikacji do izolowanego modelu procesu roboczego w celu uzyskania pełnej obsługi.

Więcej przykładów dla powiązania danych wyjściowych usługi Azure SQL jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do ToDoItem klasy i odpowiedniej tabeli bazy danych:

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

Aby zwrócić wiele powiązań wyjściowych w naszych przykładach , utworzymy niestandardowy typ zwracany:

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

Wyzwalacz HTTP, zapis jednego rekordu

W poniższym przykładzie pokazano funkcję języka C#, która dodaje rekord do bazy danych przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON. Obiekt zwracany jest klasą utworzoną OutputType do obsługi zarówno odpowiedzi HTTP, jak i powiązania wyjściowego 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; }
    }
}

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie pokazano funkcję języka C#, która dodaje rekordy do bazy danych w dwóch różnych tabelach (dbo.ToDo i dbo.RequestLog), używając danych podanych w żądaniu HTTP POST jako treści kodu JSON i wielu powiązań wyjściowych.

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

Aby użyć dodatkowego powiązania wyjściowego, dodamy klasę i RequestLog zmodyfikujemy naszą OutputType klasę:

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

}

Więcej przykładów dla powiązania danych wyjściowych usługi Azure SQL jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do ToDoItem klasy (w osobnym pliku ToDoItem.java) i odpowiedniej tabeli bazy danych:

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

Wyzwalacz HTTP, zapisywanie rekordu w tabeli

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL w funkcji Języka Java, która dodaje rekord do tabeli przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON. Funkcja przyjmuje dodatkową zależność od biblioteki com.google.code.gson , aby przeanalizować treść 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();
    }
}

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL w funkcji JavaS, która dodaje rekordy do bazy danych w dwóch różnych tabelach (dbo.ToDo i dbo.RequestLog), przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych. Funkcja przyjmuje dodatkową zależność od biblioteki com.google.code.gson , aby przeanalizować treść JSON.

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

Druga tabela dbo.RequestLogodpowiada następującej definicji:

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

i java, klasa w :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();
    }
}

Więcej przykładów dla powiązania danych wyjściowych usługi Azure SQL jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do tabeli bazy danych:

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

Wyzwalacz HTTP, zapisywanie rekordów w tabeli

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL, które dodaje rekordy do tabeli przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON.

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

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL, które dodaje rekordy do bazy danych w dwóch różnych tabelach (dbo.ToDo i dbo.RequestLog), przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych.

Druga tabela dbo.RequestLogodpowiada następującej definicji:

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

Więcej przykładów dla powiązania danych wyjściowych usługi Azure SQL jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do tabeli bazy danych:

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

Wyzwalacz HTTP, zapisywanie rekordów w tabeli

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL w pliku function.json i funkcję programu PowerShell, która dodaje rekordy do tabeli przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON.

Poniżej przedstawiono powiązanie danych w pliku function.json:

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

W sekcji konfiguracji opisano te właściwości.

Poniżej przedstawiono przykładowy kod programu PowerShell dla funkcji w run.ps1 pliku :


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

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie pokazano powiązanie danych wyjściowych SQL w pliku function.json i funkcję programu PowerShell, która dodaje rekordy do bazy danych w dwóch różnych tabelach (dbo.ToDo i dbo.RequestLog), przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych.

Druga tabela dbo.RequestLogodpowiada następującej definicji:

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

Poniżej przedstawiono powiązanie danych w pliku function.json:

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

W sekcji konfiguracji opisano te właściwości.

Poniżej przedstawiono przykładowy kod programu PowerShell dla funkcji w run.ps1 pliku :

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

Więcej przykładów dla powiązania danych wyjściowych usługi Azure SQL jest dostępnych w repozytorium GitHub.

Ta sekcja zawiera następujące przykłady:

Przykłady odnoszą się do tabeli bazy danych:

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

Wyzwalacz HTTP, zapisywanie rekordów w tabeli

Poniższy przykład przedstawia powiązanie danych wyjściowych SQL w pliku function.json i funkcję języka Python, która dodaje rekordy do tabeli przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON.

Poniżej przedstawiono przykładowy kod języka Python dla pliku function_app.py:

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

Wyzwalacz HTTP, zapis w dwóch tabelach

W poniższym przykładzie przedstawiono powiązanie danych wyjściowych SQL w pliku function.json i funkcję języka Python, która dodaje rekordy do bazy danych w dwóch różnych tabelach (dbo.ToDo i dbo.RequestLog), przy użyciu danych podanych w żądaniu HTTP POST jako treści JSON i wielu powiązań wyjściowych.

Druga tabela dbo.RequestLogodpowiada następującej definicji:

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

Poniżej przedstawiono przykładowy kod języka Python dla pliku 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
        )

Atrybuty

Biblioteka języka C# używa atrybutu SqlAttribute do deklarowania powiązań SQL w funkcji, która ma następujące właściwości:

Właściwość atrybutu opis
Tekst polecenia Wymagany. Nazwa tabeli zapisywanej przez powiązanie.
ConnectionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, do której są zapisywane dane. Nie jest to rzeczywista parametry połączenia i zamiast tego musi zostać rozpoznana zmienna środowiskowa.

Adnotacje

W bibliotece środowiska uruchomieniowego funkcji Języka Java użyj @SQLOutput adnotacji (com.microsoft.azure.functions.sql.annotation.SQLOutput) dla parametrów, których wartość pochodzi z usługi Azure SQL. Ta adnotacja obsługuje następujące elementy:

Element opis
commandText Wymagany. Nazwa tabeli zapisywanej przez powiązanie.
connectionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, do której są zapisywane dane. Nie jest to rzeczywista parametry połączenia i zamiast tego musi zostać rozpoznana zmienna środowiskowa.
name Wymagany. Unikatowa nazwa powiązania funkcji.

Konfigurowanie

W poniższej tabeli opisano właściwości, które można ustawić dla options obiektu przekazanego output.sql() do metody .

Właściwości opis
commandText Wymagany. Nazwa tabeli zapisywanej przez powiązanie.
connectionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, do której są zapisywane dane. Nie jest to rzeczywista parametry połączenia i zamiast tego musi zostać rozpoznana zmienna środowiskowa. Opcjonalne słowa kluczowe w wartości parametry połączenia są dostępne do uściślinia łączności powiązań SQL.

Konfigurowanie

W poniższej tabeli opisano właściwości konfiguracji powiązania ustawione w pliku function.json .

właściwość function.json opis
type Wymagany. Musi być ustawiona wartość sql.
direction Wymagany. Musi być ustawiona wartość out.
name Wymagany. Nazwa zmiennej reprezentującej jednostkę w kodzie funkcji.
commandText Wymagany. Nazwa tabeli zapisywanej przez powiązanie.
connectionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, do której są zapisywane dane. Nie jest to rzeczywista parametry połączenia i zamiast tego musi zostać rozpoznana zmienna środowiskowa. Opcjonalne słowa kluczowe w wartości parametry połączenia są dostępne do uściślinia łączności powiązań SQL.

Podczas tworzenia aplikacji lokalnie dodaj ustawienia aplikacji w pliku local.settings.json w kolekcji Values .

Użycie

Właściwość CommandText to nazwa tabeli, w której mają być przechowywane dane. Nazwa ustawienia parametry połączenia odpowiada ustawieniu aplikacji zawierającemu parametry połączenia wystąpienia usługi Azure SQL lub programu SQL Server.

Powiązania wyjściowe używają instrukcji T-SQL MERGE , która wymaga uprawnień SELECT w docelowej bazie danych.

Jeśli wystąpi wyjątek podczas wykonywania powiązania danych wyjściowych SQL, kod funkcji przestaje działać. Może to spowodować zwrócenie kodu błędu, takiego jak wyzwalacz HTTP zwracający kod błędu 500. IAsyncCollector Jeśli element jest używany w funkcji .NET, kod funkcji może obsługiwać wyjątki zgłaszane przez wywołanie metody FlushAsync().

Następne kroki