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.
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:
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.RequestLog
tö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; }
}
}
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:
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.RequestLog
a 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:
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.
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-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.RequestLog
a 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
)
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 };
},
});
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:
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.RequestLog
a 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:
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.
Az alábbiakban a function_app.py fájlhoz tartozó Python-mintakódot íme:
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-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.RequestLog
a 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
)
Az alábbiakban a function_app.py fájlhoz tartozó Python-mintakódot íme:
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
)
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. |
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. |
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ó
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. |
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 sql következőnek kell lennie: . |
direction | Szükséges. A beállításnak a out kö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 SELECT-engedélyekre van szükség 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.