Dela via


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.

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

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

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

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

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

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:

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.

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

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.

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

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

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

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

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:

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.

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

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.

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

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

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

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

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 (=).

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