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

  • Artykuł

Po uruchomieniu funkcji powiązanie wejściowe usługi Azure SQL pobiera dane z bazy danych i przekazuje je do parametru wejściowego funkcji.

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

Ważne

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

Przykłady

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

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

Ważne

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

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

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

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

namespace AzureSQL.ToDo
{
    public class ToDoItem
    {
        public Guid Id { get; set; }
        public int? order { get; set; }
        public string title { get; set; }
        public string url { get; set; }
        public bool? completed { get; set; }
    }
}

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

Wyzwalacz HTTP, pobieranie wiersza według identyfikatora z ciągu zapytania

W poniższym przykładzie pokazano funkcję języka C#, która pobiera pojedynczy rekord. Funkcja jest wyzwalana przez żądanie HTTP, które używa ciągu zapytania do określenia identyfikatora. Ten identyfikator służy do pobierania rekordu ToDoItem z określonym zapytaniem.

Uwaga

Parametr ciągu zapytania HTTP uwzględnia wielkość liter.

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

Wyzwalacz HTTP, pobieranie wielu wierszy z parametru trasy

W poniższym przykładzie pokazano funkcję języka C#, która pobiera dokumenty zwracane przez zapytanie. Funkcja jest wyzwalana przez żądanie HTTP, które używa danych trasy do określenia wartości parametru zapytania. Ten parametr służy do filtrowania ToDoItem rekordów w określonym zapytaniu.

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

Wyzwalacz HTTP, usuwanie wierszy

W poniższym przykładzie przedstawiono funkcję języka C#, która wykonuje procedurę składowaną z danymi wejściowymi z parametru zapytania żądania HTTP.

Procedura dbo.DeleteToDo składowana musi zostać utworzona w bazie danych SQL. W tym przykładzie procedura składowana usuwa pojedynczy rekord lub wszystkie rekordy w zależności od wartości parametru.

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

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

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

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

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

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

    public ToDoItem() {
    }

    public ToDoItem(UUID Id, int order, String title, String url, boolean completed) {
        this.Id = Id;
        this.order = order;
        this.title = title;
        this.url = url;
        this.completed = completed;
    }
}

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

Wyzwalacz HTTP, pobieranie wielu wierszy

Poniższy przykład przedstawia powiązanie danych wejściowych SQL w funkcji Java wyzwalanej przez żądanie HTTP i odczytuje je z zapytania i zwraca wyniki w odpowiedzi HTTP.

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

Wyzwalacz HTTP, pobieranie wiersza według identyfikatora z ciągu zapytania

W poniższym przykładzie pokazano powiązanie danych wejściowych SQL w funkcji Java, która jest wyzwalana przez żądanie HTTP i odczytuje z zapytania przefiltrowanego przez parametr z ciągu zapytania i zwraca wiersz w odpowiedzi HTTP .

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

Wyzwalacz HTTP, usuwanie wierszy

Poniższy przykład przedstawia powiązanie wejściowe SQL w funkcji Java wyzwalanej przez żądanie HTTP i wykonuje procedurę składowaną z danymi wejściowymi z parametru zapytania żądania HTTP .

Procedura dbo.DeleteToDo składowana musi zostać utworzona w bazie danych. W tym przykładzie procedura składowana usuwa pojedynczy rekord lub wszystkie rekordy w zależności od wartości parametru.

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

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

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

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

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

Wyzwalacz HTTP, pobieranie wielu wierszy

Poniższy przykład przedstawia powiązanie danych wejściowych SQL wyzwalane przez żądanie HTTP i odczytuje je z zapytania i zwraca wyniki w odpowiedzi HTTP .

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

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

Wyzwalacz HTTP, pobieranie wiersza według identyfikatora z ciągu zapytania

Poniższy przykład przedstawia powiązanie danych wejściowych SQL wyzwalane przez żądanie HTTP i odczytuje je z zapytania filtrowanego przez parametr z ciągu zapytania i zwraca wiersz w odpowiedzi HTTP.

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

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

Wyzwalacz HTTP, usuwanie wierszy

W poniższym przykładzie pokazano powiązanie danych wejściowych SQL wyzwalane przez żądanie HTTP i wykonuje procedurę składowaną z danymi wejściowymi z parametru zapytania żądania HTTP .

Procedura dbo.DeleteToDo składowana musi zostać utworzona w bazie danych. W tym przykładzie procedura składowana usuwa pojedynczy rekord lub wszystkie rekordy w zależności od wartości parametru.

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

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

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

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

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

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

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

Wyzwalacz HTTP, pobieranie wielu wierszy

Poniższy przykład przedstawia powiązanie danych wejściowych SQL w pliku function.json i funkcję programu PowerShell, która jest wyzwalana przez żądanie HTTP i odczytuje z zapytania i zwraca wyniki w odpowiedzi HTTP .

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

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

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

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

using namespace System.Net

param($Request, $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
})

Wyzwalacz HTTP, pobieranie wiersza według identyfikatora z ciągu zapytania

Poniższy przykład przedstawia powiązanie danych wejściowych SQL w funkcji programu PowerShell, która jest wyzwalana przez żądanie HTTP i odczytuje z zapytania filtrowanego przez parametr z ciągu zapytania i zwraca wiersz w odpowiedzi HTTP .

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

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

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

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

using namespace System.Net

param($Request, $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
})

Wyzwalacz HTTP, usuwanie wierszy

W poniższym przykładzie pokazano powiązanie wejściowe SQL w pliku function.json i funkcję programu PowerShell, która jest wyzwalana przez żądanie HTTP i wykonuje procedurę składowaną z danymi wejściowymi z parametru zapytania żądania HTTP.

Procedura dbo.DeleteToDo składowana musi zostać utworzona w bazie danych. W tym przykładzie procedura składowana usuwa pojedynczy rekord lub wszystkie rekordy w zależności od wartości parametru.

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

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

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

using namespace System.Net

param($Request, $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
})

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

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

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

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

Wyzwalacz HTTP, pobieranie wielu wierszy

W poniższym przykładzie pokazano powiązanie danych wejściowych SQL w pliku function.json i funkcję języka Python wyzwalaną przez żądanie HTTP i odczytane z zapytania i zwraca wyniki w odpowiedzi HTTP.

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

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

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

Poniżej przedstawiono przykładowy kod w języku Python:

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

Wyzwalacz HTTP, pobieranie wiersza według identyfikatora z ciągu zapytania

Poniższy przykład przedstawia powiązanie danych wejściowych SQL w funkcji języka Python, która jest wyzwalana przez żądanie HTTP i odczytuje z zapytania przefiltrowanego przez parametr z ciągu zapytania i zwraca wiersz w odpowiedzi HTTP .

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

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

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

Poniżej przedstawiono przykładowy kod w języku Python:

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

Wyzwalacz HTTP, usuwanie wierszy

Poniższy przykład przedstawia powiązanie wejściowe SQL w pliku function.json i funkcję języka Python wyzwalaną przez żądanie HTTP i wykonuje procedurę składowaną z danymi wejściowymi z parametru zapytania żądania HTTP .

Procedura dbo.DeleteToDo składowana musi zostać utworzona w bazie danych. W tym przykładzie procedura składowana usuwa pojedynczy rekord lub wszystkie rekordy w zależności od wartości parametru.

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": "$return"
},
{
    "name": "todoItems",
    "type": "sql",
    "direction": "in",
    "commandText": "DeleteToDo",
    "commandType": "StoredProcedure",
    "parameters": "@Id = {Query.id}",
    "connectionStringSetting": "SqlConnectionString"
}

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

Poniżej przedstawiono przykładowy kod w języku Python:

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

Atrybuty

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

Właściwość atrybutu opis
Commandtext Wymagany. Polecenie zapytania Transact-SQL lub nazwa procedury składowanej wykonywanej przez powiązanie.
Połączenie ionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, na której jest wykonywane zapytanie lub procedura składowana. Ta wartość nie jest rzeczywistą parametry połączenia i zamiast tego musi zostać rozpoznana jako nazwa zmiennej środowiskowej.
Commandtype Wymagany. Wartość CommandType, która jest wartością Text dla zapytania i StoredProcedure dla procedury składowanej.
Parametry Opcjonalny. Zero lub więcej wartości parametrów przekazanych do polecenia podczas wykonywania jako pojedynczy ciąg. Musi być zgodny z formatem @param1=param1,@param2=param2. Ani nazwa parametru, ani wartość parametru nie mogą zawierać przecinka (,) lub znaku równości (=).

Adnotacje

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

Element opis
Commandtext Wymagany. Polecenie zapytania Transact-SQL lub nazwa procedury składowanej wykonywanej przez powiązanie.
connectionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, na której jest wykonywane zapytanie lub procedura składowana. Ta wartość nie jest rzeczywistą parametry połączenia i zamiast tego musi zostać rozpoznana jako nazwa zmiennej środowiskowej.
Commandtype Wymagany. Wartość CommandType, która jest "Tekst" dla zapytania i "StoredProcedure" dla procedury składowanej.
name Wymagany. Unikatowa nazwa powiązania funkcji.
parameters Opcjonalny. Zero lub więcej wartości parametrów przekazanych do polecenia podczas wykonywania jako pojedynczy ciąg. Musi być zgodny z formatem @param1=param1,@param2=param2. Ani nazwa parametru, ani wartość parametru nie mogą zawierać przecinka (,) lub znaku równości (=).

Konfigurowanie

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

Właściwości opis
Commandtext Wymagany. Polecenie zapytania Transact-SQL lub nazwa procedury składowanej wykonywanej przez powiązanie.
connectionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, na której jest wykonywane zapytanie lub procedura składowana. Ta wartość nie jest rzeczywistą parametry połączenia i zamiast tego musi zostać rozpoznana jako nazwa zmiennej środowiskowej. Opcjonalne słowa kluczowe w wartości parametry połączenia są dostępne do uściślinia łączności powiązań SQL.
Commandtype Wymagany. Wartość CommandType, która jest wartością Text dla zapytania i StoredProcedure dla procedury składowanej.
parameters Opcjonalny. Zero lub więcej wartości parametrów przekazanych do polecenia podczas wykonywania jako pojedynczy ciąg. Musi być zgodny z formatem @param1=param1,@param2=param2. Ani nazwa parametru, ani wartość parametru nie mogą zawierać przecinka (,) lub znaku równości (=).

Konfigurowanie

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

właściwość function.json opis
type Wymagany. Musi być ustawiona wartość sql.
direction Wymagany. Musi być ustawiona wartość in.
name Wymagany. Nazwa zmiennej reprezentującej zapytanie powoduje wyświetlenie kodu funkcji.
Commandtext Wymagany. Polecenie zapytania Transact-SQL lub nazwa procedury składowanej wykonywanej przez powiązanie.
connectionStringSetting Wymagany. Nazwa ustawienia aplikacji zawierającego parametry połączenia dla bazy danych, na której jest wykonywane zapytanie lub procedura składowana. Ta wartość nie jest rzeczywistą parametry połączenia i zamiast tego musi zostać rozpoznana jako nazwa zmiennej środowiskowej. Opcjonalne słowa kluczowe w wartości parametry połączenia są dostępne do uściślinia łączności powiązań SQL.
Commandtype Wymagany. Wartość CommandType, która jest wartością Text dla zapytania i StoredProcedure dla procedury składowanej.
parameters Opcjonalny. Zero lub więcej wartości parametrów przekazanych do polecenia podczas wykonywania jako pojedynczy ciąg. Musi być zgodny z formatem @param1=param1,@param2=param2. Ani nazwa parametru, ani wartość parametru nie mogą zawierać przecinka (,) lub znaku równości (=).

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

Użycie

Konstruktor atrybutu przyjmuje tekst polecenia SQL, typ polecenia, parametry i nazwę ustawienia parametry połączenia. Polecenie może być zapytaniem języka Transact-SQL (T-SQL) z typem System.Data.CommandType.Text polecenia lub nazwą procedury składowanej o typie System.Data.CommandType.StoredProcedurepolecenia . Nazwa ustawienia parametry połączenia odpowiada ustawieniu aplikacji (w local.settings.json programie na potrzeby programowania lokalnego), które zawiera parametry połączenia wystąpienia usługi Azure SQL lub programu SQL Server.

Zapytania wykonywane przez powiązanie wejściowe są sparametryzowane w programie Microsoft.Data.SqlClient, aby zmniejszyć ryzyko wstrzyknięcia kodu SQL z wartości parametrów przekazanych do powiązania.

Jeśli wystąpi wyjątek podczas wykonywania powiązania wejściowego SQL, kod funkcji nie zostanie wykonany. Może to spowodować zwrócenie kodu błędu, takiego jak wyzwalacz HTTP zwracający kod błędu 500.

Następne kroki