Azure Database for MySQL-indatabindning för Azure Functions

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

Information om installation och konfiguration 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

Du kan skapa en C#-funktion 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. En isolerad arbetsprocess krävs för att stödja C#-funktioner som körs på långsiktig support (LTS) och icke-LTS-versioner för .NET och .NET Framework.
• Processmodell: Kompilerad C#-funktion som körs i samma process som Azure Functions-körningen.
• C#-skript: Används främst när du skapar C#-funktioner i Azure Portal.

Isolerad arbetsmodell

Fler exempel för Azure Database for MySQL-indatabindningen finns på GitHub-lagringsplatsen.

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

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

Exemplen refererar till en Product klass och en motsvarande databastabell:

namespace AzureMySqlSamples.Common
{
    public class Product
    {
        public int? ProductId { get; set; }

        public string Name { get; set; }

        public int Cost { get; set; }

        public override bool Equals(object obj)
    }
}

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

HTTP-utlösare, hämta en rad efter ID från en 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 Product post med den angivna frågan.

Kommentar

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

using System.Collections.Generic;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Azure.Functions.Worker;
using Microsoft.Azure.Functions.Worker.Extensions.MySql;
using Microsoft.Azure.Functions.Worker.Http;
using AzureMySqlSamples.Common;

namespace AzureMySqlSamples.InputBindingIsolatedSamples
{
    public static class GetProductById
    {
        [Function(nameof(GetProductById))]
        public static IEnumerable<Product> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "getproducts/{productId}")]
            HttpRequestData req,
            [MySqlInput("select * from Products where ProductId = @productId",
                "MySqlConnectionString",
                parameters: "@ProductId={productId}")]
            IEnumerable<Product> products)
        {
            return products;
        }
    }
}

HTTP-utlösare, hämta flera rader från en vägparameter

I följande exempel visas en C#-funktion som hämtar rader som frågan returnerade. 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 Product 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.MySql;
using Microsoft.Azure.Functions.Worker.Http;
using AzureMySqlSamples.Common;

namespace AzureMySqlSamples.InputBindingIsolatedSamples
{
    public static class GetProducts
    {
        [Function(nameof(GetProducts))]
        public static IEnumerable<Product> Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "getproducts")]
            HttpRequestData req,
            [MySqlInput("select * from Products",
                "MySqlConnectionString")]
            IEnumerable<Product> products)
        {
            return products;
        }
    }
}

HTTP-utlösare, ta bort rader

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

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

DROP PROCEDURE IF EXISTS DeleteProductsCost;

Create Procedure DeleteProductsCost(cost INT)
BEGIN
  DELETE from Products where Products.cost = cost;
END

namespace AzureMySqlSamples.InputBindingSamples
{
    public static class GetProductsStoredProcedure
    {
        [FunctionName(nameof(GetProductsStoredProcedure))]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "getproducts-storedprocedure/{cost}")]
            HttpRequest req,
            [MySql("DeleteProductsCost",
                "MySqlConnectionString",
                commandType: System.Data.CommandType.StoredProcedure,
                parameters: "@Cost={cost}")]
            IEnumerable<Product> products)
        {
            return new OkObjectResult(products);
        }
    }
}

Processmodell

Fler exempel för Azure Database for MySQL-indatabindningen finns på GitHub-lagringsplatsen.

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

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

Exemplen refererar till en Product klass och en motsvarande databastabell:

namespace AzureMySqlSamples.Common
{
    public class Product
    {
        public int? ProductId { get; set; }

        public string Name { get; set; }

        public int Cost { get; set; }

        public override bool Equals(object obj)
    }
}

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

HTTP-utlösare, hämta en rad efter ID från en 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 Product post med den angivna frågan.

Kommentar

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

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

namespace AzureMySqlSamples.InputBindingSamples
{
    public static class GetProductById
    {
        [FunctionName("GetProductById")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", Route = "getproducts/{productId}")] HttpRequest req,
            [MySql("select * from Products where ProductId = @productId",
                "MySqlConnectionString",
                parameters: "@ProductId={productId}")]
            IEnumerable<Product> products)
        {
            return new OkObjectResult(products);
        }
    }
}

HTTP-utlösare, hämta flera rader från en vägparameter

I följande exempel visas en C#-funktion som hämtar dokument som frågan returnerade. 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 Product 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;
using Microsoft.Azure.WebJobs.Extensions.MySql;
using AzureMySqlSamples.Common;

namespace AzureMySqlSamples.InputBindingSamples
{
    public static class GetProducts
    {
        [FunctionName("GetProducts")]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Function, "get", Route = "getproducts")] HttpRequest req,
            [MySql("select * from Products",
                "MySqlConnectionString")]
            IEnumerable<Product> products)
        {
            return new OkObjectResult(products);
        }
    }
}

HTTP-utlösare, ta bort rader

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

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

DROP PROCEDURE IF EXISTS DeleteProductsCost;

Create Procedure DeleteProductsCost(cost INT)
BEGIN
  DELETE from Products where Products.cost = cost;
END

namespace AzureMySqlSamples.InputBindingSamples
{
    public static class GetProductsStoredProcedure
    {
        [FunctionName(nameof(GetProductsStoredProcedure))]
        public static IActionResult Run(
            [HttpTrigger(AuthorizationLevel.Anonymous, "get", Route = "getproducts-storedprocedure/{cost}")]
            HttpRequest req,
            [MySql("DeleteProductsCost",
                "MySqlConnectionString",
                commandType: System.Data.CommandType.StoredProcedure,
                parameters: "@Cost={cost}")]
            IEnumerable<Product> products)
        {
            return new OkObjectResult(products);
        }
    }
}

Fler exempel för Azure Database for MySQL-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 en rad efter ID från en frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en Product klass och en motsvarande databastabell:

package com.function.Common;

import com.fasterxml.jackson.annotation.JsonProperty;

public class Product {
    @JsonProperty("ProductId")
    private int ProductId;
    @JsonProperty("Name")
    private String Name;
    @JsonProperty("Cost")
    private int Cost;

    public Product() {
    }

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

HTTP-utlösare, hämta flera rader

I följande exempel visas en Azure Database for MySQL-indatabindning i en Java-funktion som en HTTP-begäran utlöser. Bindningen läser från en fråga och returnerar resultatet i HTTP-svaret.

package com.function;

import com.function.Common.Product;
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.mysql.annotation.CommandType;
import com.microsoft.azure.functions.mysql.annotation.MySqlInput;

import java.util.Optional;

public class GetProducts {
    @FunctionName("GetProducts")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS,
                route = "getproducts}")
                HttpRequestMessage<Optional<String>> request,
            @MySqlInput(
                name = "products",
                commandText = "SELECT * FROM Products",
                commandType = CommandType.Text,
                connectionStringSetting = "MySqlConnectionString")
                Product[] products) {

        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(products).build();
    }
}

HTTP-utlösare, hämta en rad efter ID från en frågesträng

I följande exempel visas en Azure Database for MySQL-indatabindning i en Java-funktion som en HTTP-begäran utlöser. Bindningen läser från en fråga som filtreras efter en parameter från frågesträngen och returnerar raden i HTTP-svaret.

public class GetProductById {
    @FunctionName("GetProductById")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS,
                route = "getproducts/{productid}")
                HttpRequestMessage<Optional<String>> request,
            @MySqlInput(
                name = "products",
                commandText = "SELECT * FROM Products WHERE ProductId= @productId",
                commandType = CommandType.Text,
                parameters = "@productId={productid}",
                connectionStringSetting = "MySqlConnectionString")
                Product[] products) {

        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(products).build();
    }
}

HTTP-utlösare, ta bort rader

I följande exempel visas en Azure Database for MySQL-indatabindning i en Java-funktion som en HTTP-begäran utlöser. Bindningen kör en lagrad procedur med indata från HTTP-begärans frågeparameter.

Den lagrade proceduren DeleteProductsCost 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.

DROP PROCEDURE IF EXISTS DeleteProductsCost;

Create Procedure DeleteProductsCost(cost INT)
BEGIN
  DELETE from Products where Products.cost = cost;
END

public class DeleteProductsStoredProcedure {
    @FunctionName("DeleteProductsStoredProcedure")
    public HttpResponseMessage run(
            @HttpTrigger(
                name = "req",
                methods = {HttpMethod.GET},
                authLevel = AuthorizationLevel.ANONYMOUS,
                route = "Deleteproducts-storedprocedure/{cost}")
                HttpRequestMessage<Optional<String>> request,
            @MySqlInput(
                name = "products",
                commandText = "DeleteProductsCost",
                commandType = CommandType.StoredProcedure,
                parameters = "@Cost={cost}",
                connectionStringSetting = "MySqlConnectionString")
                Product[] products) {

        return request.createResponseBuilder(HttpStatus.OK).header("Content-Type", "application/json").body(products).build();
    }
}

Fler exempel för Azure Database for MySQL-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 en rad efter ID från en frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en databastabell:

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

HTTP-utlösare, hämta flera rader

I följande exempel visas en Azure Database for MySQL-indatabindning som en HTTP-begäran utlöser. Bindningen 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 mysqlInput = input.generic({
    commandText: 'select * from Products',
    commandType: 'Text',
    connectionStringSetting: 'MySqlConnectionString',
});

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

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

Modell v3

TypeScript-exempel dokumenteras inte för model v3.

Modell v4

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

const mysqlInput = input.generic({
    type: 'mysql',
    commandText: 'select * from Products where Cost = @Cost',
    parameters: '@Cost={Cost}',
    commandType: 'Text',
    connectionStringSetting: 'MySqlConnectionString'
})

app.http('GetProducts', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    route: 'getproducts/{cost}',
    extraInputs: [mysqlInput],
    handler: async (request, context) => {
        const products = JSON.stringify(context.extraInputs.get(mysqlInput));

        return {
            status: 200,
            body: products
        };
    }
});

Modell v3

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

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get"
      ],
      "route": "getproducts"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "products",
      "type": "mysql",
      "direction": "in",
      "commandText": "select * from Products",
      "commandType": "Text",
      "connectionStringSetting": "MySqlConnectionString"
    }
  ],
  "disabled": false
}

I avsnittet Konfiguration beskrivs dessa egenskaper.

Följande exempel är JavaScript-exempelkod:

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

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

HTTP-utlösare, hämta en rad efter ID från en frågesträng

I följande exempel visas en Azure Database for MySQL-indatabindning som en HTTP-begäran utlöser. Bindningen läser från en fråga som filtreras efter 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 mysqlInput = input.generic({
    commandText: 'select * from Products where ProductId= @productId',
    commandType: 'Text',
    parameters: '@productId={productid}',
    connectionStringSetting: 'MySqlConnectionString',
});

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

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

Modell v3

TypeScript-exempel dokumenteras inte för model v3.

Modell v4

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

const mysqlInput = input.generic({
    type: 'mysql',
    commandText: 'select * from Products where ProductId= @productId',
    commandType: 'Text',
    parameters: '@productId={productid}',
    connectionStringSetting: 'MySqlConnectionString'
})

app.http('GetProducts', {
    methods: ['GET', 'POST'],
    authLevel: 'anonymous',
    route: 'getproducts/{productid}',
    extraInputs: [mysqlInput],
    handler: async (request, context) => {
        const products = JSON.stringify(context.extraInputs.get(mysqlInput));

        return {
            status: 200,
            body: products
        };
    }
});

Modell v3

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

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get"
      ],
      "route": "getproducts/{productid}"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "products",
      "type": "mysql",
      "direction": "in",
      "commandText": "select * from Products where ProductId= @productId",
      "commandType": "Text",
      "parameters": "@productId={productid}",
      "connectionStringSetting": "MySqlConnectionString"
    }
  ],
  "disabled": false
}

I avsnittet Konfiguration beskrivs dessa egenskaper.

Följande exempel är JavaScript-exempelkod:

module.exports = async function (context, req, products) {
    context.log('JavaScript HTTP trigger function processed a request.');
    context.log(JSON.stringify(products));
    return {
        status: 200,
        body: products
    };
}

HTTP-utlösare, ta bort rader

I följande exempel visas en Azure Database for MySQL-indatabindning som en HTTP-begäran utlöser. Bindningen kör en lagrad procedur med indata från HTTP-begärans frågeparameter.

Den lagrade proceduren DeleteProductsCost 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.

DROP PROCEDURE IF EXISTS DeleteProductsCost;

Create Procedure DeleteProductsCost(cost INT)
BEGIN
  DELETE from Products where Products.cost = cost;
END

Modell v4

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

const mysqlInput = input.generic({
    commandText: 'DeleteProductsCost',
    commandType: 'StoredProcedure',
    parameters: '@Cost={cost}',
    connectionStringSetting: 'MySqlConnectionString',
});

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

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

Modell v3

TypeScript-exempel dokumenteras inte för model v3.

Modell v4

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

const mysqlInput = input.generic({
    type: 'mysql',
    commandText: 'DeleteProductsCost',
    commandType: 'StoredProcedure',
    parameters: '@Cost={cost}',
    connectionStringSetting: 'MySqlConnectionString'
})

app.http('httpTrigger1', {
    methods: ['POST'],
    authLevel: 'anonymous',
    route: 'DeleteProductsByCost',
    extraInputs: [mysqlInput],
    handler: async (request, context) => {
        const products = JSON.stringify(context.extraInputs.get(mysqlInput));

        return {
            status: 200,
            body: products
        };
    }
});

Modell v3

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get"
      ],
      "route": "DeleteProductsByCost"
    },
    {
      "name": "$return",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "products",
      "type": "mysql",
      "direction": "in",
      "commandText": "DeleteProductsCost",
      "commandType": "StoredProcedure",
      "parameters": "@Cost={cost}",
      "connectionStringSetting": "MySqlConnectionString"
    }
  ],
  "disabled": false
}

I avsnittet Konfiguration beskrivs dessa egenskaper.

Följande exempel är JavaScript-exempelkod:

module.exports = async function (context, req, products) {
    context.log('JavaScript HTTP trigger function processed a request.');
    context.log(JSON.stringify(products));
    return {
        status: 200,
        body: products
    };
}

Fler exempel för Azure Database for MySQL-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 en rad efter ID från en frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en databastabell:

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

HTTP-utlösare, hämta flera rader

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

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

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "Request",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get"
      ],
      "route": "getproducts/{cost}"
    },
    {
      "name": "response",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "products",
      "type": "mysql",
      "direction": "in",
      "commandText": "select * from Products",
      "commandType": "Text",
      "connectionStringSetting": "MySqlConnectionString"
    }
  ],
  "disabled": false
}

I avsnittet Konfiguration beskrivs dessa egenskaper.

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

using namespace System.Net

param($Request, $TriggerMetadata, $products)

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

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

HTTP-utlösare, hämta en rad efter ID från en frågesträng

I följande exempel visas en Azure Database for MySQL-indatabindning i en PowerShell-funktion som en HTTP-begäran utlöser. Bindningen läser från en fråga som filtreras efter en parameter från frågesträngen och returnerar raden i HTTP-svaret.

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

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "Request",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get"
      ],
      "route": "getproducts/{productid}"
    },
    {
      "name": "response",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "products",
      "type": "mysql",
      "direction": "in",
      "commandText": "select * from Products where ProductId= @productId",
      "commandType": "Text",
      "parameters": "MySqlConnectionString",
      "connectionStringSetting": "MySqlConnectionString"
    }
  ],
  "disabled": false
}

I avsnittet Konfiguration beskrivs dessa egenskaper.

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

using namespace System.Net

param($Request, $TriggerMetadata, $products)

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

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

HTTP-utlösare, ta bort rader

I följande exempel visas en Azure Database for MySQL-indatabindning i en function.json-fil och en PowerShell-funktion som en HTTP-begäran utlöser. Bindningen kör en lagrad procedur med indata från HTTP-begärans frågeparameter.

Den lagrade proceduren DeleteProductsCost 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.

DROP PROCEDURE IF EXISTS DeleteProductsCost;

Create Procedure DeleteProductsCost(cost INT)
BEGIN
  DELETE from Products where Products.cost = 'cost';
END

{
  "bindings": [
    {
      "authLevel": "function",
      "name": "Request",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get"
      ],
      "route": "deleteproducts-storedprocedure/{cost}"
    },
    {
      "name": "response",
      "type": "http",
      "direction": "out"
    },
    {
      "name": "products",
      "type": "mysql",
      "direction": "in",
      "commandText": "DeleteProductsCost",
      "commandType": "StoredProcedure",
      "parameters": "@Cost={cost}",
      "connectionStringSetting": "MySqlConnectionString"
    }
  ],
  "disabled": false
}

I avsnittet Konfiguration beskrivs dessa egenskaper.

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

using namespace System.Net

param($Request, $TriggerMetadata, $products)

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

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

Fler exempel för Azure Database for MySQL-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 en rad efter ID från en frågesträng
• HTTP-utlösare, ta bort rader

Exemplen refererar till en databastabell:

DROP TABLE IF EXISTS Products;

CREATE TABLE Products (
  ProductId int PRIMARY KEY,
  Name varchar(100) NULL,
  Cost int NULL
);

Kommentar

Du måste använda Azure Functions version 1.22.0b4 för Python.

HTTP-utlösare, hämta flera rader

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

v2

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

import azure.functions as func
import datetime
import json
import logging

app = func.FunctionApp()


@app.generic_trigger(arg_name="req", type="httpTrigger", route="getproducts/{cost}")
@app.generic_output_binding(arg_name="$return", type="http")
@app.generic_input_binding(arg_name="products", type="mysql",
                           commandText= "select * from Products",
                           command_type="Text",
                           connection_string_setting="MySqlConnectionString")
def mysql_test(req: func.HttpRequest, products: func.MySqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), products))

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

v1

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

{
    "bindings": [
      {
        "authLevel": "function",
        "name": "req",
        "type": "httpTrigger",
        "direction": "in",
        "methods": [
          "get"
        ],
        "route": "getproducts/{cost}"
      },
      {
        "name": "$return",
        "type": "http",
        "direction": "out"
      },
      {
        "name": "products",
        "type": "mysql",
        "direction": "in",
        "commandText": "select * from Products",
        "commandType": "Text",
        "connectionStringSetting": "MySqlConnectionString"
      }
    ],
    "disabled": false
  }

I avsnittet Konfiguration beskrivs dessa egenskaper.

Följande exempel är Python-exempelkod:

import azure.functions as func
import json

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

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

HTTP-utlösare, hämta en rad efter ID från en frågesträng

I följande exempel visas en Azure Database for MySQL-indatabindning i en Python-funktion som en HTTP-begäran utlöser. Bindningen läser från en fråga som filtreras efter en parameter från frågesträngen och returnerar raden i HTTP-svaret.

v2

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

import azure.functions as func
import datetime
import json
import logging

app = func.FunctionApp()


@app.generic_trigger(arg_name="req", type="httpTrigger", route="getproducts/{cost}")
@app.generic_output_binding(arg_name="$return", type="http")
@app.generic_input_binding(arg_name="products", type="mysql",
                           commandText= "select * from Products where ProductId= @productId",
                           command_type="Text",
                           parameters= "@productId={productid}",
                           connection_string_setting="MySqlConnectionString")
def mysql_test(req: func.HttpRequest, products: func.MySqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), products))

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

v1

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

{
    "bindings": [
      {
        "authLevel": "function",
        "name": "req",
        "type": "httpTrigger",
        "direction": "in",
        "methods": [
          "get"
        ],
        "route": "getproducts/{productid}"
      },
      {
        "name": "$return",
        "type": "http",
        "direction": "out"
      },
      {
        "name": "products",
        "type": "mysql",
        "direction": "in",
        "commandText": "select * from Products where ProductId= @productId",
        "commandType": "Text",
        "parameters": "@productId={productid}",
        "connectionStringSetting": "MySqlConnectionString"
      }
    ],
    "disabled": false
  }

I avsnittet Konfiguration beskrivs dessa egenskaper.

Följande exempel är Python-exempelkod:

import azure.functions as func
import json

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

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

HTTP-utlösare, ta bort rader

I följande exempel visas en Azure Database for MySQL-indatabindning i en function.json-fil och en Python-funktion som en HTTP-begäran utlöser. Bindningen kör en lagrad procedur med indata från HTTP-begärans frågeparameter.

Den lagrade proceduren DeleteProductsCost 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.

DROP PROCEDURE IF EXISTS DeleteProductsCost;

Create Procedure DeleteProductsCost(cost INT)
BEGIN
  DELETE from Products where Products.cost = cost;
END

v2

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

import azure.functions as func
import datetime
import json
import logging

app = func.FunctionApp()


@app.generic_trigger(arg_name="req", type="httpTrigger", route="getproducts/{cost}")
@app.generic_output_binding(arg_name="$return", type="http")
@app.generic_input_binding(arg_name="products", type="mysql",
                           commandText= "DeleteProductsCost",
                           command_type="StoredProcedure",
                           parameters= "@Cost={cost}",
                           connection_string_setting="MySqlConnectionString")
def mysql_test(req: func.HttpRequest, products: func.MySqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), products))

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

v1

    "bindings": [
      {
        "authLevel": "function",
        "name": "req",
        "type": "httpTrigger",
        "direction": "in",
        "methods": [
          "get"
        ],
        "route": "getproducts-storedprocedure/{cost}"
      },
      {
        "name": "$return",
        "type": "http",
        "direction": "out"
      },
      {
        "name": "products",
        "type": "mysql",
        "direction": "in",
        "commandText": "DeleteProductsCost",
        "commandType": "StoredProcedure",
        "parameters": "@Cost={cost}",
        "connectionStringSetting": "MySqlConnectionString"
      }
    ],
    "disabled": false
  }

I avsnittet Konfiguration beskrivs dessa egenskaper.

Följande exempel är Python-exempelkod:

import json
import azure.functions as func

# The input binding executes the `SELECT * FROM Products WHERE Cost = @Cost` query.
# The Parameters argument passes the `{cost}` specified in the URL that triggers the function,
# `getproducts/{cost}`, as the value of the `@Cost` parameter in the query.
# CommandType is set to `Text`, because the constructor argument of the binding is a raw query.
def main(req: func.HttpRequest, products: func.MySqlRowList) -> func.HttpResponse:
    rows = list(map(lambda r: json.loads(r.to_json()), products))

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

Attribut

C#-biblioteket använder MySqlAttribute attributet för att deklarera MySQL-bindningar för funktionen. Attributet har följande egenskaper:

Attributegenskap	beskrivning
CommandText	Obligatoriskt. MySQL-frågekommandot eller namnet på den lagrade procedur som bindningen kör.
ConnectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller anslutningssträngen för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska anslutningssträng 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. Parameternamnet och parametervärdet får inte innehålla kommatecken (,) eller likhetstecken (=).

Kommentarer

I Java Functions-körningsbiblioteket använder du anteckningen @MySQLInput för parametrar vars värden skulle komma från Azure Database for MySQL. Den här kommentaren stöder följande element:

Komponent	beskrivning
commandText	Obligatoriskt. MySQL-frågekommandot eller namnet på den lagrade procedur som bindningen kör.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller anslutningssträngen för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska anslutningssträng 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.
name	Obligatoriskt. 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. Parameternamnet och parametervärdet får inte 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.generic() till metoden:

Fastighet	beskrivning
commandText	Obligatoriskt. MySQL-frågekommandot eller namnet på den lagrade procedur som bindningen kör.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller anslutningssträngen för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska anslutningssträng och måste i stället matchas mot ett miljövariabelnamn. Valfria nyckelord i anslutningssträng-värdet är tillgängliga för att förfina Anslutningen för MySQL-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. Parameternamnet och parametervärdet får inte innehålla kommatecken (,) eller likhetstecken (=).

Modell v3

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

Fastighet	beskrivning
type	Obligatoriskt. Måste anges till Mysql.
direction	Obligatoriskt. Måste anges till in.
name	Obligatoriskt. Namnet på variabeln som representerar frågan resulterar i funktionskod.
commandText	Obligatoriskt. MySQL-frågekommandot eller namnet på den lagrade procedur som bindningen kör.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller anslutningssträngen för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska anslutningssträng och måste i stället matchas mot ett miljövariabelnamn. Valfria nyckelord i anslutningssträng-värdet är tillgängliga för att förfina Anslutningen för MySQL-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. Parameternamnet och parametervärdet får inte innehålla kommatecken (,) eller likhetstecken (=).

Konfiguration

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

Fastighet	beskrivning
type	Obligatoriskt. Måste anges till mysql.
direction	Obligatoriskt. Måste anges till in.
name	Obligatoriskt. Namnet på variabeln som representerar frågan resulterar i funktionskod.
commandText	Obligatoriskt. MySQL-frågekommandot eller namnet på den lagrade procedur som bindningen kör.
connectionStringSetting	Obligatoriskt. Namnet på en appinställning som innehåller anslutningssträngen för databasen som frågan eller den lagrade proceduren körs mot. Det här värdet är inte det faktiska anslutningssträng och måste i stället matchas mot ett miljövariabelnamn. Valfria nyckelord i anslutningssträng-värdet är tillgängliga för att förfina Anslutningen för MySQL-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. Parameternamnet och parametervärdet får inte 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.

Förbrukning

Attributets konstruktor tar MySQL-kommandotexten, kommandotypen, parametrarna och namnet på inställningen för anslutningssträngen. Kommandot kan vara en MySQL-fråga med kommandotypen System.Data.CommandType.Text eller ett lagrat procedurnamn med kommandotypen System.Data.CommandType.StoredProcedure. Namnet på inställningen för anslutningssträngen motsvarar programinställningen (i local.settings.json för lokal utveckling) som innehåller anslutningssträngen till Azure Database for MySQL.

Om ett undantag inträffar när en Azure Database for MySQL-indatabindning körs slutar funktionskoden att köras. Resultatet kan vara en felkod, till exempel en HTTP-utlösare som returnerar en 500-felkod.

Relaterat innehåll

• Spara data i en databas (utdatabindning)
• Kör en funktion från en HTTP-begäran (utlösare)