Azure SQL-indatabindning för Azure Functions

När en funktion körs hämtar Azure SQL-indatabindningen data från en databas och skickar dem till indataparametern för funktionen.

Information om konfiguration och konfigurationsinformation finns i översikten.

Viktigt!

Den här artikeln använder flikar för att stödja flera versioner av Node.js programmeringsmodellen. V4-modellen är allmänt tillgänglig och är utformad för att ha en mer flexibel och intuitiv upplevelse för JavaScript- och TypeScript-utvecklare. Mer information om hur v4-modellen fungerar finns i utvecklarguiden för Azure Functions Node.js. Mer information om skillnaderna mellan v3 och v4 finns i migreringsguiden.

Exempel

En C#-funktion kan skapas med något av följande C#-lägen:

• Isolerad arbetsmodell: Kompilerad C#-funktion som körs i en arbetsprocess som är isolerad från körningen. Isolerad arbetsprocess krävs för att stödja C#-funktioner som körs på LTS- och icke-LTS-versioner .NET och .NET Framework.
• Processmodell: Kompilerad C#-funktion som körs i samma process som Functions-körningen.
• C#-skript: Används främst när du skapar C#-funktioner i Azure-portalen.

Viktigt!

Supporten upphör för den pågående modellen den 10 november 2026. Vi rekommenderar starkt att du migrerar dina appar till den isolerade arbetsmodellen för fullt stöd.

Isolerad arbetsmodell

Fler exempel för Azure SQL-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

• HTTP-utlösare, hämta rad efter ID från frågesträng
• HTTP-utlösare, hämta flera rader från routningsdata
• HTTP-utlösare, ta bort rader

Exemplen refererar till en ToDoItem klass och en motsvarande databastabell:

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-utlösare, hämta rad efter ID från frågesträng

I följande exempel visas en C#-funktion som hämtar en enda post. Funktionen utlöses av en HTTP-begäran som använder en frågesträng för att ange ID:t. Det ID:t används för att hämta en ToDoItem post med den angivna frågan.

Kommentar

HTTP-frågesträngsparametern är skiftlägeskänslig.

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-utlösare, hämta flera rader från vägparametern

I följande exempel visas en C#-funktion som hämtar dokument som returneras av frågan. Funktionen utlöses av en HTTP-begäran som använder routningsdata för att ange värdet för en frågeparameter. Parametern används för att filtrera posterna ToDoItem i den angivna frågan.

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-utlösare, ta bort rader

I följande exempel visas en C#-funktion som kör en lagrad procedur med indata från frågeparametern HTTP-begäran.

Den lagrade proceduren dbo.DeleteToDo måste skapas i SQL-databasen. I det här exemplet tar den lagrade proceduren bort en enskild post eller alla poster beroende på parameterns värde.

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

Processmodell

Fler exempel för Azure SQL-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

• HTTP-utlösare, hämta rad efter ID från frågesträng
• HTTP-utlösare, hämta flera rader från routningsdata
• HTTP-utlösare, ta bort rader

Exemplen refererar till en ToDoItem klass och en motsvarande databastabell:

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-utlösare, hämta rad efter ID från frågesträng

I följande exempel visas en C#-funktion som hämtar en enda post. Funktionen utlöses av en HTTP-begäran som använder en frågesträng för att ange ID:t. Det ID:t används för att hämta en ToDoItem post med den angivna frågan.

Kommentar

HTTP-frågesträngsparametern är skiftlägeskänslig.

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-utlösare, hämta flera rader från vägparametern

I följande exempel visas en C#-funktion som hämtar dokument som returneras av frågan. Funktionen utlöses av en HTTP-begäran som använder routningsdata för att ange värdet för en frågeparameter. Parametern används för att filtrera posterna ToDoItem i den angivna frågan.

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-utlösare, ta bort rader

I följande exempel visas en C#-funktion som kör en lagrad procedur med indata från frågeparametern HTTP-begäran.

Den lagrade proceduren dbo.DeleteToDo måste skapas i SQL-databasen. I det här exemplet tar den lagrade proceduren bort en enskild post eller alla poster beroende på parameterns värde.

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

Fler exempel för Azure SQL-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

• HTTP-utlösare, hämta flera rader
• HTTP-utlösare, hämta rad efter ID från frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en ToDoItem klass (i en separat fil ToDoItem.java) och en motsvarande databastabell:

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-utlösare, hämta flera rader

I följande exempel visas en SQL-indatabindning i en Java-funktion som utlöses av en HTTP-begäran och läser från en fråga och returnerar resultatet i HTTP-svaret.

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-utlösare, hämta rad efter ID från frågesträng

I följande exempel visas en SQL-indatabindning i en Java-funktion som utlöses av en HTTP-begäran och som läses från en fråga filtrerad av en parameter från frågesträngen och returnerar raden i HTTP-svaret.

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-utlösare, ta bort rader

I följande exempel visas en SQL-indatabindning i en Java-funktion som utlöses av en HTTP-begäran och kör en lagrad procedur med indata från frågeparametern HTTP-begäran.

Den lagrade proceduren dbo.DeleteToDo måste skapas i databasen. I det här exemplet tar den lagrade proceduren bort en enskild post eller alla poster beroende på parameterns värde.

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

Fler exempel för Azure SQL-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

• HTTP-utlösare, hämta flera rader
• HTTP-utlösare, hämta rad efter ID från frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en databastabell:

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-utlösare, hämta flera rader

I följande exempel visas en SQL-indatabindning som utlöses av en HTTP-begäran och läser från en fråga och returnerar resultatet i HTTP-svaret.

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

TypeScript-exempel dokumenteras inte för model v3.

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

Följande är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är JavaScript-exempelkod:

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-utlösare, hämta rad efter ID från frågesträng

I följande exempel visas en SQL-indatabindning som utlöses av en HTTP-begäran och läser från en fråga som filtreras av en parameter från frågesträngen och returnerar raden i HTTP-svaret.

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

TypeScript-exempel dokumenteras inte för model v3.

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

Följande är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är JavaScript-exempelkod:

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-utlösare, ta bort rader

I följande exempel visas en SQL-indatabindning som utlöses av en HTTP-begäran och kör en lagrad procedur med indata från frågeparametern HTTP-begäran.

Den lagrade proceduren dbo.DeleteToDo måste skapas i databasen. I det här exemplet tar den lagrade proceduren bort en enskild post eller alla poster beroende på parameterns värde.

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

TypeScript-exempel dokumenteras inte för model v3.

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är JavaScript-exempelkod:

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

Fler exempel för Azure SQL-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

• HTTP-utlösare, hämta flera rader
• HTTP-utlösare, hämta rad efter ID från frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en databastabell:

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-utlösare, hämta flera rader

I följande exempel visas en SQL-indatabindning i en function.json-fil och en PowerShell-funktion som utlöses av en HTTP-begäran och läser från en fråga och returnerar resultatet i HTTP-svaret.

Följande är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är exempel på PowerShell-kod för funktionen i run.ps1 filen:

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-utlösare, hämta rad efter ID från frågesträng

I följande exempel visas en SQL-indatabindning i en PowerShell-funktion som utlöses av en HTTP-begäran och läser från en fråga som filtrerats av en parameter från frågesträngen och returnerar raden i HTTP-svaret.

Följande är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är exempel på PowerShell-kod för funktionen i run.ps1 filen:

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-utlösare, ta bort rader

I följande exempel visas en SQL-indatabindning i en function.json-fil och en PowerShell-funktion som utlöses av en HTTP-begäran och kör en lagrad procedur med indata från frågeparametern HTTP-begäran.

Den lagrade proceduren dbo.DeleteToDo måste skapas i databasen. I det här exemplet tar den lagrade proceduren bort en enskild post eller alla poster beroende på parameterns värde.

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är exempel på PowerShell-kod för funktionen i run.ps1 filen:

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

Fler exempel för Azure SQL-indatabindningen finns på GitHub-lagringsplatsen.

Det här avsnittet innehåller följande exempel:

• HTTP-utlösare, hämta flera rader
• HTTP-utlösare, hämta rad efter ID från frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en databastabell:

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-utlösare, hämta flera rader

I följande exempel visas en SQL-indatabindning i en function.json-fil och en Python-funktion som utlöses av en HTTP-begäran och läser från en fråga och returnerar resultatet i HTTP-svaret.

v2

Följande är python-exempelkod för function_app.py-filen:

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

Följande är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är python-exempelkod:

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-utlösare, hämta rad efter ID från frågesträng

I följande exempel visas en SQL-indatabindning i en Python-funktion som utlöses av en HTTP-begäran och som läses från en fråga filtrerad av en parameter från frågesträngen och returnerar raden i HTTP-svaret.

v2

Följande är python-exempelkod för function_app.py-filen:

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

Följande är bindningsdata i function.json-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är python-exempelkod:

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-utlösare, ta bort rader

I följande exempel visas en SQL-indatabindning i en function.json-fil och en Python-funktion som utlöses av en HTTP-begäran och kör en lagrad procedur med indata från frågeparametern HTTP-begäran.

Den lagrade proceduren dbo.DeleteToDo måste skapas i databasen. I det här exemplet tar den lagrade proceduren bort en enskild post eller alla poster beroende på parameterns värde.

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

Följande är python-exempelkod för function_app.py-filen:

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

I konfigurationsavsnittet förklaras dessa egenskaper.

Följande är python-exempelkod:

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

Attribut

C#-biblioteket använder attributet SqlAttribute för att deklarera SQL-bindningar för funktionen, som har följande egenskaper:

Attributegenskap	beskrivning
CommandText	Obligatoriskt. Transact-SQL-frågekommandot eller namnet på den lagrade proceduren som körs av bindningen.
ConnectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller niska veze för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska niska veze och måste i stället matchas mot ett miljövariabelnamn.
CommandType	Obligatoriskt. Ett CommandType-värde , som är Text för en fråga och StoredProcedure för en lagrad procedur.
Parameters	Valfritt. Noll eller fler parametervärden som skickas till kommandot under körningen som en enskild sträng. Måste följa formatet @param1=param1,@param2=param2. Varken parameternamnet eller parametervärdet får innehålla kommatecken (,) eller likhetstecken (=).

Kommentarer

I Java Functions-körningsbiblioteket använder du anteckningen @SQLInput (com.microsoft.azure.functions.sql.annotation.SQLInput) för parametrar vars värde skulle komma från Azure SQL. Den här kommentaren stöder följande element:

Element	Description
commandText	Obligatoriskt. Transact-SQL-frågekommandot eller namnet på den lagrade proceduren som körs av bindningen.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller niska veze för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska niska veze och måste i stället matchas mot ett miljövariabelnamn.
commandType	Obligatoriskt. Ett CommandType-värde , som är "Text" för en fråga och "StoredProcedure" för en lagrad procedur.
Namn	Obligatoriska. Funktionsbindningens unika namn.
parameters	Valfritt. Noll eller fler parametervärden som skickas till kommandot under körningen som en enskild sträng. Måste följa formatet @param1=param1,@param2=param2. Varken parameternamnet eller parametervärdet får innehålla kommatecken (,) eller likhetstecken (=).

Konfiguration

Modell v4

I följande tabell förklaras de egenskaper som du kan ange för objektet options som skickas input.sql() till metoden.

Property	beskrivning
commandText	Obligatoriskt. Transact-SQL-frågekommandot eller namnet på den lagrade proceduren som körs av bindningen.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller niska veze för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska niska veze och måste i stället matchas mot ett miljövariabelnamn. Valfria nyckelord i niska veze-värdet är tillgängliga för att förfina SQL-bindningar.
commandType	Obligatoriskt. Ett CommandType-värde , som är Text för en fråga och StoredProcedure för en lagrad procedur.
parameters	Valfritt. Noll eller fler parametervärden som skickas till kommandot under körningen som en enskild sträng. Måste följa formatet @param1=param1,@param2=param2. Varken parameternamnet eller parametervärdet får innehålla kommatecken (,) eller likhetstecken (=).

Modell v3

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i function.json-filen.

Property	Beskrivning
typ	Obligatoriska. Måste anges till sql.
riktning	Obligatoriskt. Måste anges till in.
Namn	Obligatoriska. Namnet på variabeln som representerar frågan resulterar i funktionskod.
commandText	Obligatoriskt. Transact-SQL-frågekommandot eller namnet på den lagrade proceduren som körs av bindningen.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller niska veze för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska niska veze och måste i stället matchas mot ett miljövariabelnamn. Valfria nyckelord i niska veze-värdet är tillgängliga för att förfina SQL-bindningar.
commandType	Obligatoriskt. Ett CommandType-värde , som är Text för en fråga och StoredProcedure för en lagrad procedur.
parameters	Valfritt. Noll eller fler parametervärden som skickas till kommandot under körningen som en enskild sträng. Måste följa formatet @param1=param1,@param2=param2. Varken parameternamnet eller parametervärdet får innehålla kommatecken (,) eller likhetstecken (=).

Konfiguration

I följande tabell förklaras de bindningskonfigurationsegenskaper som du anger i function.json-filen.

function.json egenskap	beskrivning
typ	Obligatoriska. Måste anges till sql.
riktning	Obligatoriskt. Måste anges till in.
Namn	Obligatoriska. Namnet på variabeln som representerar frågan resulterar i funktionskod.
commandText	Obligatoriskt. Transact-SQL-frågekommandot eller namnet på den lagrade proceduren som körs av bindningen.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller niska veze för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska niska veze och måste i stället matchas mot ett miljövariabelnamn. Valfria nyckelord i niska veze-värdet är tillgängliga för att förfina SQL-bindningar.
commandType	Obligatoriskt. Ett CommandType-värde , som är Text för en fråga och StoredProcedure för en lagrad procedur.
parameters	Valfritt. Noll eller fler parametervärden som skickas till kommandot under körningen som en enskild sträng. Måste följa formatet @param1=param1,@param2=param2. Varken parameternamnet eller parametervärdet får innehålla kommatecken (,) eller likhetstecken (=).

När du utvecklar lokalt lägger du till dina programinställningar i den local.settings.json filen i Values samlingen.

Användning

Attributets konstruktor tar SQL-kommandotexten, kommandotypen, parametrarna och niska veze inställningsnamnet. Kommandot kan vara en Transact-SQL-fråga (T-SQL) med kommandotypen System.Data.CommandType.Text eller namnet på den lagrade proceduren med kommandotypen System.Data.CommandType.StoredProcedure. Det niska veze inställningsnamnet motsvarar programinställningen (i local.settings.json för lokal utveckling) som innehåller niska veze till Azure SQL- eller SQL Server-instansen.

Frågor som körs av indatabindningen parametriseras i Microsoft.Data.SqlClient för att minska risken för SQL-inmatning från de parametervärden som skickas till bindningen.

Om ett undantag inträffar när en SQL-indatabindning körs körs inte funktionskoden. Detta kan leda till att en felkod returneras, till exempel en HTTP-utlösare som returnerar en 500-felkod.

Nästa steg

• Spara data i en databas (utdatabindning)
• Kör en funktion när data ändras i en SQL-tabell (utlösare)
• Kör en funktion från en HTTP-begäran (utlösare)
• Granska ToDo API-exempel med Azure SQL-bindningar