Share via


Azure SQL-uitvoerbinding voor Azure Functions

Met de Azure SQL-uitvoerbinding kunt u schrijven naar een database.

Zie het overzicht voor informatie over het instellen en configureren van details.

Belangrijk

In dit artikel worden tabbladen gebruikt ter ondersteuning van meerdere versies van het Node.js programmeermodel. Het v4-model is algemeen beschikbaar en is ontworpen voor een flexibelere en intuïtievere ervaring voor JavaScript- en TypeScript-ontwikkelaars. Raadpleeg de ontwikkelaarshandleiding voor Azure Functions Node.js voor meer informatie over hoe het v4-model werkt. Raadpleeg de migratiehandleiding voor meer informatie over de verschillen tussen v3 en v4.

Voorbeelden

U kunt een C#-functie maken met behulp van een van de volgende C#-modi:

  • Geïsoleerd werkrolmodel: gecompileerde C#-functie die wordt uitgevoerd in een werkproces dat is geïsoleerd van de runtime. Geïsoleerd werkproces is vereist voor de ondersteuning van C#-functies die worden uitgevoerd op LTS- en niet-LTS-versies .NET en .NET Framework.
  • In-process model: gecompileerde C#-functie die wordt uitgevoerd in hetzelfde proces als de Functions-runtime.
  • C#-script: wordt voornamelijk gebruikt wanneer u C#-functies maakt in Azure Portal.

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

De voorbeelden verwijzen naar een ToDoItem klasse en een bijbehorende databasetabel:

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

Als u meerdere uitvoerbindingen in onze voorbeelden wilt retourneren, maken we een aangepast retourtype:

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

HTTP-trigger, één record schrijven

In het volgende voorbeeld ziet u een C#-functie waarmee een record wordt toegevoegd aan een database, waarbij gegevens worden gebruikt die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst. Het retourobject is de OutputType klasse die we hebben gemaakt om zowel een HTTP-antwoord als de SQL-uitvoerbinding te verwerken.

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

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

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

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

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

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

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

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

        public HttpResponseData HttpResponse { get; set; }
    }
}

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een C#-functie die records toevoegt aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

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

Als u een extra uitvoerbinding wilt gebruiken, voegen we een klasse toe voor RequestLog en wijzigen we onze OutputType klasse:

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

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

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

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

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

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

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

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

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

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

        public HttpResponseData HttpResponse { get; set; }
    }

}

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

De voorbeelden verwijzen naar een ToDoItem klasse (in een afzonderlijk bestand ToDoItem.java) en een bijbehorende databasetabel:

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

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

    public ToDoItem() {
    }

    public ToDoItem(UUID Id, int order, String title, String url, boolean completed) {
        this.Id = Id;
        this.order = order;
        this.title = title;
        this.url = url;
        this.completed = completed;
    }
}
CREATE TABLE dbo.ToDo (
    [Id] UNIQUEIDENTIFIER PRIMARY KEY,
    [order] INT NULL,
    [title] NVARCHAR(200) NOT NULL,
    [url] NVARCHAR(200) NOT NULL,
    [completed] BIT NOT NULL
);

HTTP-trigger, een record naar een tabel schrijven

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een Java-functie waarmee een record aan een tabel wordt toegevoegd, met behulp van gegevens in een HTTP POST-aanvraag als JSON-hoofdtekst. De functie heeft een extra afhankelijkheid van de com.google.code.gson-bibliotheek om de JSON-hoofdtekst te parseren.

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

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

import java.util.Optional;

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

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

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

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een JavaS-functie die records toevoegt aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen. De functie heeft een extra afhankelijkheid van de com.google.code.gson-bibliotheek om de JSON-hoofdtekst te parseren.

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

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

en Java-klasse in RequestLog.java:

package com.function;

import java.util.Date;

public class RequestLog {
    public int Id;
    public Date RequestTimeStamp;
    public int ItemCount;

    public RequestLog() {
    }

    public RequestLog(int Id, Date RequestTimeStamp, int ItemCount) {
        this.Id = Id;
        this.RequestTimeStamp = RequestTimeStamp;
        this.ItemCount = ItemCount;
    }
}
package com.function;

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

import java.util.Optional;

public class PostToDoWithLog {
    @FunctionName("PostToDoWithLog")
    public HttpResponseMessage run(
            @HttpTrigger(name = "req", methods = {HttpMethod.POST}, authLevel = AuthorizationLevel.ANONYMOUS) HttpRequestMessage<Optional<String>> request,
            @SQLOutput(
                name = "toDoItem",
                commandText = "dbo.ToDo",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<ToDoItem> output,
            @SQLOutput(
                name = "requestLog",
                commandText = "dbo.RequestLog",
                connectionStringSetting = "SqlConnectionString")
                OutputBinding<RequestLog> outputLog,
            final ExecutionContext context) {
        context.getLogger().info("Java HTTP trigger processed a request.");

        String json = request.getBody().get();
        Gson gson = new Gson();
        ToDoItem newToDo = gson.fromJson(json, ToDoItem.class);
        newToDo.Id = UUID.randomUUID();
        output.setValue(newToDo);

        RequestLog newLog = new RequestLog();
        newLog.ItemCount = 1;
        outputLog.setValue(newLog);

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

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

De voorbeelden verwijzen naar een databasetabel:

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

HTTP-trigger, records schrijven naar een tabel

In het volgende voorbeeld ziet u een SQL-uitvoerbinding waarmee records aan een tabel worden toegevoegd met behulp van gegevens in een HTTP POST-aanvraag als JSON-hoofdtekst.

import { app, HttpRequest, HttpResponseInit, InvocationContext, output } from '@azure/functions';

const sqlOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL output binding function processed a request.');

    const body = await request.json();
    context.extraOutputs.set(sqlOutput, body);
    return { status: 201 };
}

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlOutput],
    handler: httpTrigger1,
});
const { app, output } = require('@azure/functions');

const sqlOutput = output.sql({
    commandText: 'dbo.ToDo',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    extraOutputs: [sqlOutput],
    handler: async (request, context) => {
        context.log('HTTP trigger and SQL output binding function processed a request.');

        const body = await request.json();
        context.extraOutputs.set(sqlOutput, body);
        return { status: 201 };
    },
});

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding die records toevoegt aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

De voorbeelden verwijzen naar een databasetabel:

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

HTTP-trigger, records schrijven naar een tabel

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een PowerShell-functie waarmee records worden toegevoegd aan een tabel, waarbij gegevens worden gebruikt die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst.

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een PowerShell-voorbeeldcode voor de functie in het run.ps1 bestand:


```powershell
using namespace System.Net

param($Request)

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

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

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

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

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een PowerShell-functie waarmee records worden toegevoegd aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

Hier volgen bindingsgegevens in het function.json-bestand:

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

In de configuratiesectie worden deze eigenschappen uitgelegd.

Hier volgt een PowerShell-voorbeeldcode voor de functie in het run.ps1 bestand:

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

Meer voorbeelden voor de Azure SQL-uitvoerbinding zijn beschikbaar in de GitHub-opslagplaats.

Deze sectie bevat de volgende voorbeelden:

De voorbeelden verwijzen naar een databasetabel:

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

HTTP-trigger, records schrijven naar een tabel

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een Python-functie waarmee records worden toegevoegd aan een tabel, waarbij gegevens worden gebruikt die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst.

Hier volgt een python-voorbeeldcode voor het function_app.py-bestand:

import json
import logging
import azure.functions as func
from azure.functions.decorators.core import DataType

app = func.FunctionApp()

@app.function_name(name="AddToDo")
@app.route(route="addtodo")
@app.sql_output(arg_name="todo",
                        command_text="[dbo].[ToDo]",
                        connection_string_setting="SqlConnectionString")
def add_todo(req: func.HttpRequest, todo: func.Out[func.SqlRow]) -> func.HttpResponse:
    body = json.loads(req.get_body())
    row = func.SqlRow.from_dict(body)
    todo.set(row)

    return func.HttpResponse(
        body=req.get_body(),
        status_code=201,
        mimetype="application/json"
    )

HTTP-trigger, schrijven naar twee tabellen

In het volgende voorbeeld ziet u een SQL-uitvoerbinding in een function.json-bestand en een Python-functie waarmee records worden toegevoegd aan een database in twee verschillende tabellen (dbo.ToDo en dbo.RequestLog), met behulp van gegevens die zijn opgegeven in een HTTP POST-aanvraag als een JSON-hoofdtekst en meerdere uitvoerbindingen.

De tweede tabel, dbo.RequestLogkomt overeen met de volgende definitie:

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

Hier volgt een python-voorbeeldcode voor het function_app.py-bestand:

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
        )

Kenmerken

De C#-bibliotheek maakt gebruik van het kenmerk SqlAttribute om de SQL-bindingen voor de functie te declareren, die de volgende eigenschappen heeft:

Kenmerkeigenschap Beschrijving
CommandText Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
ConnectionStringSetting Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele.

Aantekeningen

Gebruik in de Java Functions Runtime-bibliotheek de @SQLOutput aantekening (com.microsoft.azure.functions.sql.annotation.SQLOutput) voor parameters waarvan de waarde afkomstig is van Azure SQL. Deze aantekening ondersteunt de volgende elementen:

Element Beschrijving
commandText Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
connectionStringSetting Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele.
name Vereist. De unieke naam van de functiebinding.

Configuratie

In de volgende tabel worden de eigenschappen uitgelegd die u kunt instellen voor het options object dat aan de output.sql() methode is doorgegeven.

Eigenschappen Beschrijving
commandText Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
connectionStringSetting Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele. Optionele trefwoorden in de verbindingsreeks-waarde zijn beschikbaar om de connectiviteit van SQL-bindingen te verfijnen.

Configuratie

In de volgende tabel worden de bindingsconfiguratie-eigenschappen uitgelegd die u in het function.json-bestand hebt ingesteld.

function.json-eigenschap Beschrijving
type Vereist. Moet worden ingesteld op sql.
direction Vereist. Moet worden ingesteld op out.
name Vereist. De naam van de variabele die de entiteit in functiecode vertegenwoordigt.
commandText Vereist. De naam van de tabel waarnaar wordt geschreven door de binding.
connectionStringSetting Vereist. De naam van een app-instelling die de verbindingsreeks voor de database bevat waarnaar gegevens worden geschreven. Dit is niet de werkelijke verbindingsreeks en moet in plaats daarvan worden omgezet in een omgevingsvariabele. Optionele trefwoorden in de verbindingsreeks-waarde zijn beschikbaar om de connectiviteit van SQL-bindingen te verfijnen.

Wanneer u lokaal ontwikkelt, voegt u uw toepassingsinstellingen toe aan het local.settings.json-bestand in de Values verzameling.

Gebruik

De CommandText eigenschap is de naam van de tabel waarin de gegevens moeten worden opgeslagen. De naam van de verbindingsreeks-instelling komt overeen met de toepassingsinstelling die de verbindingsreeks bevat naar het Azure SQL- of SQL Server-exemplaar.

De uitvoerbindingen maken gebruik van de T-SQL MERGE-instructie waarvoor SELECT-machtigingen zijn vereist voor de doeldatabase.

Als er een uitzondering optreedt wanneer een SQL-uitvoerbinding wordt uitgevoerd, stopt de functiecode met uitvoeren. Dit kan ertoe leiden dat er een foutcode wordt geretourneerd, zoals een HTTP-trigger die een 500-foutcode retourneert. Als de IAsyncCollector functie wordt gebruikt in een .NET-functie, kan de functiecode uitzonderingen verwerken die worden veroorzaakt door de aanroep naar FlushAsync().

Volgende stappen