Azure SQL bemeneti kötés az Azure Functionshez

Amikor egy függvény fut, az Azure SQL bemeneti kötése adatokat kér le egy adatbázisból, és átadja azokat a függvény bemeneti paraméterének.

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 bemeneti 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ó, sor lekérése azonosító alapján a lekérdezési sztringből
• HTTP-eseményindító, több sor lekérése az útvonaladatokból
• HTTP-eseményindító, sorok törlése

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ó, sor lekérése azonosító alapján a lekérdezési sztringből

Az alábbi példa egy C# függvényt mutat be, amely egyetlen rekordot kér le. A függvényt egy HTTP-kérés aktiválja, amely egy lekérdezési sztringet használ az azonosító megadásához. Ez az azonosító egy rekord lekérésére ToDoItem szolgál a megadott lekérdezéssel.

Feljegyzés

A HTTP lekérdezési sztring paramétere megkülönbözteti a kis- és nagybetűk értékét.

using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItem
    {
        [FunctionName("GetToDoItem")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitem")]
            HttpRequest req,
            [SqlInput(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
                commandType: System.Data.CommandType.Text,
                parameters: "@Id={Query.id}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItem)
        {
            return new OkObjectResult(toDoItem.FirstOrDefault());
        }
    }
}

HTTP-eseményindító, több sor lekérése az útvonalparaméterből

Az alábbi példa egy C# függvényt mutat be, amely lekéri a lekérdezés által visszaadott dokumentumokat. A függvényt egy HTTP-kérés aktiválja, amely útvonaladatokat használ egy lekérdezési paraméter értékének megadásához. Ez a paraméter a megadott lekérdezés rekordjainak szűrésére ToDoItem szolgál.

using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.Sql;
using Microsoft.Azure.Functions.Worker.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItems
    {
        [FunctionName("GetToDoItems")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitems/{priority}")]
            HttpRequest req,
            [SqlInput(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where [Priority] > @Priority",
                commandType: System.Data.CommandType.Text,
                parameters: "@Priority={priority}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

HTTP-eseményindító, sorok törlése

Az alábbi példa egy C# függvényt mutat be, amely egy tárolt eljárást hajt végre a HTTP-kérelem lekérdezési paraméterének bemenetével.

A tárolt eljárást dbo.DeleteToDo létre kell hozni az SQL-adatbázisban. Ebben a példában a tárolt eljárás egyetlen rekordot vagy az összes rekordot törli a paraméter értékétől függően.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

namespace AzureSQL.ToDo
{
    public static class DeleteToDo
    {
        // delete all items or a specific item from querystring
        // returns remaining items
        // uses input binding with a stored procedure DeleteToDo to delete items and return remaining items
        [FunctionName("DeleteToDo")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "DeleteFunction")] HttpRequest req,
            ILogger log,
            [SqlInput(commandText: "DeleteToDo", commandType: System.Data.CommandType.StoredProcedure, 
                parameters: "@Id={Query.id}", connectionStringSetting: "SqlConnectionString")] 
                IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

Folyamaton belüli modell

Az Azure SQL bemeneti 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ó, sor lekérése azonosító alapján a lekérdezési sztringből
• HTTP-eseményindító, több sor lekérése az útvonaladatokból
• HTTP-eseményindító, sorok törlése

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ó, sor lekérése azonosító alapján a lekérdezési sztringből

Az alábbi példa egy C# függvényt mutat be, amely egyetlen rekordot kér le. A függvényt egy HTTP-kérés aktiválja, amely egy lekérdezési sztringet használ az azonosító megadásához. Ez az azonosító egy rekord lekérésére ToDoItem szolgál a megadott lekérdezéssel.

Feljegyzés

A HTTP lekérdezési sztring paramétere megkülönbözteti a kis- és nagybetűk értékét.

using System.Collections.Generic;
using System.Linq;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItem
    {
        [FunctionName("GetToDoItem")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitem")]
            HttpRequest req,
            [Sql(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
                commandType: System.Data.CommandType.Text,
                parameters: "@Id={Query.id}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItem)
        {
            return new OkObjectResult(toDoItem.FirstOrDefault());
        }
    }
}

HTTP-eseményindító, több sor lekérése az útvonalparaméterből

Az alábbi példa egy C# függvényt mutat be, amely lekéri a lekérdezés által visszaadott dokumentumokat. A függvényt egy HTTP-kérés aktiválja, amely útvonaladatokat használ egy lekérdezési paraméter értékének megadásához. Ez a paraméter a megadott lekérdezés rekordjainak szűrésére ToDoItem szolgál.

using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;

namespace AzureSQLSamples
{
    public static class GetToDoItems
    {
        [FunctionName("GetToDoItems")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "gettodoitems/{priority}")]
            HttpRequest req,
            [Sql(commandText: "select [Id], [order], [title], [url], [completed] from dbo.ToDo where [Priority] > @Priority",
                commandType: System.Data.CommandType.Text,
                parameters: "@Priority={priority}",
                connectionStringSetting: "SqlConnectionString")]
            IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

HTTP-eseményindító, sorok törlése

Az alábbi példa egy C# függvényt mutat be, amely egy tárolt eljárást hajt végre a HTTP-kérelem lekérdezési paraméterének bemenetével.

A tárolt eljárást dbo.DeleteToDo létre kell hozni az SQL-adatbázisban. Ebben a példában a tárolt eljárás egyetlen rekordot vagy az összes rekordot törli a paraméter értékétől függően.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

using System;
using System.Collections.Generic;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.WebJobs;
using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;

namespace AzureSQL.ToDo
{
    public static class DeleteToDo
    {
        // delete all items or a specific item from querystring
        // returns remaining items
        // uses input binding with a stored procedure DeleteToDo to delete items and return remaining items
        [FunctionName("DeleteToDo")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "delete", Route = "DeleteFunction")] HttpRequest req,
            ILogger log,
            [Sql(commandText: "DeleteToDo", commandType: System.Data.CommandType.StoredProcedure, 
                parameters: "@Id={Query.id}", connectionStringSetting: "SqlConnectionString")] 
                IEnumerable<ToDoItem> toDoItems)
        {
            return new OkObjectResult(toDoItems);
        }
    }
}

Az Azure SQL bemeneti 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ó, több sor lekérése
• HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből
• HTTP-eseményindító, sorok törlése

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ó, több sor lekérése

Az alábbi példa egy SQL-bemeneti kötést mutat be egy Java-függvényben, amelyet EGY HTTP-kérés aktivál, és egy lekérdezésből olvas be, és az eredményeket a HTTP-válaszban adja vissza.

package com.function;

import com.microsoft.azure.functions.HttpMethod;
import com.microsoft.azure.functions.HttpRequestMessage;
import com.microsoft.azure.functions.HttpResponseMessage;
import com.microsoft.azure.functions.HttpStatus;
import com.microsoft.azure.functions.annotation.AuthorizationLevel;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.annotation.HttpTrigger;
import com.microsoft.azure.functions.sql.annotation.SQLInput;

import java.util.Optional;

public class GetToDoItems {
    @FunctionName("GetToDoItems")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            @SQLInput(
                name = "toDoItems",
                commandText = "SELECT * FROM dbo.ToDo",
                commandType = "Text",
                connectionStringSetting = "SqlConnectionString")
                ToDoItem[] toDoItems) {
        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(toDoItems).build();
    }
}

HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből

Az alábbi példa egy SQL-bemeneti kötést mutat be egy Java-függvényben, amelyet EGY HTTP-kérés aktivál, és a lekérdezési sztring egy paraméterével szűrt lekérdezésből olvas be, és visszaadja a HTTP-válasz sorát.

public class GetToDoItem {
    @FunctionName("GetToDoItem")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            @SQLInput(
                name = "toDoItems",
                commandText = "SELECT * FROM dbo.ToDo",
                commandType = "Text",
                parameters = "@Id={Query.id}",
                connectionStringSetting = "SqlConnectionString")
                ToDoItem[] toDoItems) {
        ToDoItem toDoItem = toDoItems[0];
        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(toDoItem).build();
    }
}

HTTP-eseményindító, sorok törlése

Az alábbi példa egy SQL-bemeneti kötést mutat be egy Java-függvényben, amelyet egy HTTP-kérés aktivál, és egy tárolt eljárást hajt végre a HTTP-kérelem lekérdezési paraméterének bemenetével.

A tárolt eljárást dbo.DeleteToDo létre kell hozni az adatbázisban. Ebben a példában a tárolt eljárás egyetlen rekordot vagy az összes rekordot törli a paraméter értékétől függően.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

public class DeleteToDo {
    @FunctionName("DeleteToDo")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS)
                HttpRequestMessage<Optional<String>> request,
            @SQLInput(
                name = "toDoItems",
                commandText = "dbo.DeleteToDo",
                commandType = "StoredProcedure",
                parameters = "@Id={Query.id}",
                connectionStringSetting = "SqlConnectionString")
                ToDoItem[] toDoItems) {
        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(toDoItems).build();
    }
}

Az Azure SQL bemeneti 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ó, több sor lekérése
• HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből
• HTTP-eseményindító, sorok törlése

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ó, több sor lekérése

Az alábbi példa egy SQL bemeneti kötést mutat be, amelyet egy HTTP-kérés aktivál, és egy lekérdezésből olvas be, és az eredményeket a HTTP-válaszban adja vissza.

Modell v4

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

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo',
    commandType: 'Text',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL input binding function processed a request.');
    const toDoItems = context.extraInputs.get(sqlInput);
    return {
        jsonBody: toDoItems,
    };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: httpTrigger1,
});

Modell v3

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

Modell v4

const { app, input } = require('@azure/functions');

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo',
    commandType: 'Text',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: (request, context) => {
        context.log('HTTP trigger and SQL input binding function processed a request.');
        const toDoItems = context.extraInputs.get(sqlInput);
        return {
            jsonBody: toDoItems,
        };
    },
});

Modell v3

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

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo",
    "commandType": "Text",
    "connectionStringSetting": "SqlConnectionString"
}

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

A következő javaScript-mintakód:

module.exports = async function (context, req, todoItems) {
    context.log('JavaScript HTTP trigger and SQL input binding function processed a request.');

    context.res = {
        // status: 200, /* Defaults to 200 */
        mimetype: "application/json",
        body: todoItems
    };
}

HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből

Az alábbi példa egy SQL bemeneti kötést mutat be, amelyet EGY HTTP-kérés aktivál, és egy lekérdezésből olvas be egy paraméter által szűrt lekérdezésből a lekérdezési sztringből, és visszaadja a HTTP-válasz sorát.

Modell v4

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

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id',
    commandType: 'Text',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL input binding function processed a request.');
    const toDoItem = context.extraInputs.get(sqlInput);
    return {
        jsonBody: toDoItem,
    };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: httpTrigger1,
});

Modell v3

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

Modell v4

const { app, input } = require('@azure/functions');

const sqlInput = input.sql({
    commandText: 'select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id',
    commandType: 'Text',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: (request, context) => {
        context.log('HTTP trigger and SQL input binding function processed a request.');
        const toDoItem = context.extraInputs.get(sqlInput);
        return {
            jsonBody: toDoItem,
        };
    },
});

Modell v3

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

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

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

A következő javaScript-mintakód:

module.exports = async function (context, req, todoItem) {
    context.log('JavaScript HTTP trigger and SQL input binding function processed a request.');

    context.res = {
        // status: 200, /* Defaults to 200 */
        mimetype: "application/json",
        body: todoItem
    };
}

HTTP-eseményindító, sorok törlése

Az alábbi példa egy SQL bemeneti kötést mutat be, amelyet egy HTTP-kérés aktivál, és egy tárolt eljárást hajt végre a HTTP-kérelem lekérdezési paraméterének bemenetével.

A tárolt eljárást dbo.DeleteToDo létre kell hozni az adatbázisban. Ebben a példában a tárolt eljárás egyetlen rekordot vagy az összes rekordot törli a paraméter értékétől függően.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

Modell v4

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

const sqlInput = input.sql({
    commandText: 'DeleteToDo',
    commandType: 'StoredProcedure',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

export async function httpTrigger1(request: HttpRequest, context: InvocationContext): Promise<HttpResponseInit> {
    context.log('HTTP trigger and SQL input binding function processed a request.');
    const toDoItems = context.extraInputs.get(sqlInput);
    return {
        jsonBody: toDoItems,
    };
}

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: httpTrigger1,
});

Modell v3

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

Modell v4

const { app, input } = require('@azure/functions');

const sqlInput = input.sql({
    commandText: 'DeleteToDo',
    commandType: 'StoredProcedure',
    parameters: '@Id={Query.id}',
    connectionStringSetting: 'SqlConnectionString',
});

app.http('httpTrigger1', {
    methods: ['GET'],
    authLevel: 'anonymous',
    extraInputs: [sqlInput],
    handler: (request, context) => {
        context.log('HTTP trigger and SQL input binding function processed a request.');
        const toDoItems = context.extraInputs.get(sqlInput);
        return {
            jsonBody: toDoItems,
        };
    },
});

Modell v3

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

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

A következő javaScript-mintakód:

module.exports = async function (context, req, todoItems) {
    context.log('JavaScript HTTP trigger and SQL input binding function processed a request.');

    context.res = {
        // status: 200, /* Defaults to 200 */
        mimetype: "application/json",
        body: todoItems
    };
}

Az Azure SQL bemeneti 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ó, több sor lekérése
• HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből
• HTTP-eseményindító, sorok törlése

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ó, több sor lekérése

Az alábbi példa egy SQL-bemeneti kötést mutat be egy function.json fájlban és egy PowerShell-függvényben, amelyet egy HTTP-kérés aktivál, és egy lekérdezésből olvas be, és az eredményeket a HTTP-válaszban adja vissza.

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

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo",
    "commandType": "Text",
    "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, $todoItems)

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

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

HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből

Az alábbi példa egy SQL-bemeneti kötést mutat be egy PowerShell-függvényben, amelyet EGY HTTP-kérés aktivál, és egy lekérdezésből olvas be, amelyet a lekérdezési sztring egy paramétere szűr, és visszaadja a HTTP-válasz sorát.

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

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "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, $todoItem)

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

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

HTTP-eseményindító, sorok törlése

Az alábbi példa egy SQL-bemeneti kötést mutat be egy function.json fájlban és egy PowerShell-függvényben, amelyet egy HTTP-kérés aktivál, és egy tárolt eljárást hajt végre a HTTP-kérelem lekérdezési paraméterének bemenetével.

A tárolt eljárást dbo.DeleteToDo létre kell hozni az adatbázisban. Ebben a példában a tárolt eljárás egyetlen rekordot vagy az összes rekordot törli a paraméter értékétől függően.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "res"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "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, $todoItems)

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

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

Az Azure SQL bemeneti 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ó, több sor lekérése
• HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből
• HTTP-eseményindító, sorok törlése

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ó, több sor lekérése

Az alábbi példa egy SQL-bemeneti kötést mutat be egy function.json fájlban és egy Python-függvényben, amelyet egy HTTP-kérés aktivál, és egy lekérdezésből olvas be, és az eredményeket a HTTP-válaszban adja vissza.

v2

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="GetToDo")
@app.route(route="gettodo")
@app.sql_input(arg_name="todo",
                        command_text="select [Id], [order], [title], [url], [completed] from dbo.ToDo",
                        command_type="Text",
                        connection_string_setting="SqlConnectionString")
def get_todo(req: func.HttpRequest, todo: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todo))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    )

v1

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

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo",
    "commandType": "Text",
    "connectionStringSetting": "SqlConnectionString"
}

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

A következő python-mintakód:

import azure.functions as func
import json

def main(req: func.HttpRequest, todoItems: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todoItems))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    ) 

HTTP-eseményindító, sor lekérése azonosító alapján a lekérdezési sztringből

Az alábbi példa egy SQL-bemeneti kötést mutat be egy Python-függvényben, amelyet EGY HTTP-kérés aktivál, és egy lekérdezésből olvas be egy paraméter által szűrt lekérdezésből a lekérdezési sztringből, és visszaadja a HTTP-válasz sorát.

v2

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="GetToDo")
@app.route(route="gettodo/{id}")
@app.sql_input(arg_name="todo",
                        command_text="select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
                        command_type="Text",
                        parameters="@Id={id}",
                        connection_string_setting="SqlConnectionString")
def get_todo(req: func.HttpRequest, todo: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todo))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    )

v1

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

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItem",
    "type": "sql",
    "direction": "in",
    "commandText": "select [Id], [order], [title], [url], [completed] from dbo.ToDo where Id = @Id",
    "commandType": "Text",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

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

A következő python-mintakód:

import azure.functions as func
import json

def main(req: func.HttpRequest, todoItem: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todoItem))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    ) 

HTTP-eseményindító, sorok törlése

Az alábbi példa egy SQL-bemeneti kötést mutat be egy function.json fájlban és egy Python-függvényben, amelyet egy HTTP-kérés aktivál, és egy tárolt eljárást hajt végre a HTTP-kérelem lekérdezési paraméterének bemenetével.

A tárolt eljárást dbo.DeleteToDo létre kell hozni az adatbázisban. Ebben a példában a tárolt eljárás egyetlen rekordot vagy az összes rekordot törli a paraméter értékétől függően.

CREATE PROCEDURE [dbo].[DeleteToDo]
    @Id NVARCHAR(100)
AS
    DECLARE @UID UNIQUEIDENTIFIER = TRY_CAST(@ID AS UNIQUEIDENTIFIER)
    IF @UId IS NOT NULL AND @Id != ''
    BEGIN
        DELETE FROM dbo.ToDo WHERE Id = @UID
    END
    ELSE
    BEGIN
        DELETE FROM dbo.ToDo WHERE @ID = ''
    END

    SELECT [Id], [order], [title], [url], [completed] FROM dbo.ToDo
GO

v2

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="DeleteToDo")
@app.route(route="deletetodo/{id}")
@app.sql_input(arg_name="todo",
                        command_text="DeleteToDo",
                        command_type="StoredProcedure",
                        parameters="@Id={id}",
                        connection_string_setting="SqlConnectionString")
def get_todo(req: func.HttpRequest, todo: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todo))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    )

v1

{
    "authLevel": "anonymous",
    "type": "httpTrigger",
    "direction": "in",
    "name": "req",
    "methods": [
        "get"
    ]
},
{
    "type": "http",
    "direction": "out",
    "name": "$return"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

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

A következő python-mintakód:

import azure.functions as func
import json

def main(req: func.HttpRequest, todoItems: func.SqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), todoItems))

    return func.HttpResponse(
        json.dumps(rows),
        status_code=200,
        mimetype="application/json"
    ) 

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 Transact-SQL lekérdezési parancs vagy a kötés által végrehajtott tárolt eljárás neve.
ConnectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelyen a lekérdezés vagy a tárolt eljárás végrehajtása folyamatban van. Ez az érték nem a tényleges kapcsolati sztring, hanem egy környezeti változó nevére kell feloldani.
CommandType	Szükséges. CommandType-érték, amely egy lekérdezés szövege és egy tárolt eljárásHoz tartozó StoredProcedure.
Paraméterek	Opcionális. A parancsnak egyetlen sztringként átadott nulla vagy több paraméterérték. A formátumot @param1=param1,@param2=param2kell követnie. Sem a paraméter neve, sem a paraméter értéke nem tartalmazhat vesszőt (,) vagy egyenlőségjelet (=).

Jegyzetek

A Java-függvények futtatókörnyezeti kódtárában használja a széljegyzetet (com.microsoft.azure.functions.sql.annotation.SQLInput) azon @SQLInput 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 Transact-SQL lekérdezési parancs vagy a kötés által végrehajtott tárolt eljárás neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelyen a lekérdezés vagy a tárolt eljárás végrehajtása folyamatban van. Ez az érték nem a tényleges kapcsolati sztring, hanem egy környezeti változó nevére kell feloldani.
commandType	Szükséges. CommandType-érték, amely egy lekérdezés "Text" értéke, a tárolt eljáráshoz pedig "StoredProcedure".
név	Szükséges. A függvénykötés egyedi neve.
paraméterek	Opcionális. A parancsnak egyetlen sztringként átadott nulla vagy több paraméterérték. A formátumot @param1=param1,@param2=param2kell követnie. Sem a paraméter neve, sem a paraméter értéke nem tartalmazhat vesszőt (,) vagy egyenlőségjelet (=).

Konfiguráció

Modell v4

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

Tulajdonság	Leírás
commandText	Szükséges. A Transact-SQL lekérdezési parancs vagy a kötés által végrehajtott tárolt eljárás neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelyen a lekérdezés vagy a tárolt eljárás végrehajtása folyamatban van. Ez az érték nem a tényleges kapcsolati sztring, hanem egy környezeti változó nevére kell feloldani. A kapcsolati sztring érték választható kulcsszavai az SQL-kötések kapcsolatának finomításához érhetők el.
commandType	Szükséges. CommandType-érték, amely egy lekérdezés szövege és egy tárolt eljárásHoz tartozó StoredProcedure.
paraméterek	Opcionális. A parancsnak egyetlen sztringként átadott nulla vagy több paraméterérték. A formátumot @param1=param1,@param2=param2kell követnie. Sem a paraméter neve, sem a paraméter értéke nem tartalmazhat vesszőt (,) vagy egyenlőségjelet (=).

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 inkövetkezőnek kell lennie: .
név	Szükséges. A lekérdezést jelképező változó neve függvénykódot eredményez.
commandText	Szükséges. A Transact-SQL lekérdezési parancs vagy a kötés által végrehajtott tárolt eljárás neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelyen a lekérdezés vagy a tárolt eljárás végrehajtása folyamatban van. Ez az érték nem a tényleges kapcsolati sztring, hanem egy környezeti változó nevére kell feloldani. A kapcsolati sztring érték választható kulcsszavai az SQL-kötések kapcsolatának finomításához érhetők el.
commandType	Szükséges. CommandType-érték, amely egy lekérdezés szövege és egy tárolt eljárásHoz tartozó StoredProcedure.
paraméterek	Opcionális. A parancsnak egyetlen sztringként átadott nulla vagy több paraméterérték. A formátumot @param1=param1,@param2=param2kell követnie. Sem a paraméter neve, sem a paraméter értéke nem tartalmazhat vesszőt (,) vagy egyenlőségjelet (=).

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 inkövetkezőnek kell lennie: .
név	Szükséges. A lekérdezést jelképező változó neve függvénykódot eredményez.
commandText	Szükséges. A Transact-SQL lekérdezési parancs vagy a kötés által végrehajtott tárolt eljárás neve.
connectionStringSetting	Szükséges. Annak az adatbázisnak a kapcsolati sztring tartalmazó alkalmazásbeállítás neve, amelyen a lekérdezés vagy a tárolt eljárás végrehajtása folyamatban van. Ez az érték nem a tényleges kapcsolati sztring, hanem egy környezeti változó nevére kell feloldani. A kapcsolati sztring érték választható kulcsszavai az SQL-kötések kapcsolatának finomításához érhetők el.
commandType	Szükséges. CommandType-érték, amely egy lekérdezés szövege és egy tárolt eljárásHoz tartozó StoredProcedure.
paraméterek	Opcionális. A parancsnak egyetlen sztringként átadott nulla vagy több paraméterérték. A formátumot @param1=param1,@param2=param2kell követnie. Sem a paraméter neve, sem a paraméter értéke nem tartalmazhat vesszőt (,) vagy egyenlőségjelet (=).

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

Használat

Az attribútum konstruktora az SQL-parancs szövegét, a parancstípust, a paramétereket és a kapcsolati sztring beállításnevet veszi fel. A parancs lehet Transact-SQL -lekérdezés (T-SQL) a parancstípussal System.Data.CommandType.Text vagy a parancstípussal System.Data.CommandType.StoredProcedurerendelkező tárolt eljárásnévvel. A kapcsolati sztring beállítás neve megfelel az Azure SQL- vagy SQL Server-példány kapcsolati sztring tartalmazó alkalmazásbeállításnak (local.settings.jsonhelyi fejlesztés esetén).

A bemeneti kötés által végrehajtott lekérdezések paraméteresen vannak paraméterezve a Microsoft.Data.SqlClientben, hogy csökkenjen az SQL-injektálás kockázata a kötésbe átadott paraméterértékekből.

Ha kivétel történik egy SQL bemeneti kötés végrehajtásakor, akkor a függvénykód nem lesz végrehajtva. Ez egy hibakód visszaadását eredményezheti, például egy 500-as hibakódot visszaadó HTTP-eseményindítót.

Következő lépések

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