Azure Database for MySQL trigger binding for Azure Functions (preview)

More samples for the Azure Database for MySQL trigger are available in the GitHub repository.

The example refers to a Product class, a MySqlChangeProduct class, a MySqlChangeOperation enumeration, and a corresponding database table.

In a separate file named Product.java:

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

    public Product(int productId, String name, int cost) {
        ProductId = productId;
        Name = name;
        Cost = cost;
    }
}

In a separate file named MySqlChangeProduct.java:

package com.function.Common;

public class MySqlChangeProduct {
    private MySqlChangeOperation Operation;
    private Product Item;

    public MySqlChangeProduct() {
    }

    public MySqlChangeProduct(MySqlChangeOperation operation, Product item) {
        this.Operation = operation;
        this.Item = item;
    }
}

In a separate file named MySqlChangeOperation.java:

package com.function.Common;

import com.google.gson.annotations.SerializedName;

public enum MySqlChangeOperation {
    @SerializedName("0")
    Update
}

DROP TABLE IF EXISTS Products;

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

You enable change tracking on the database by adding the following column to the table:

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

The Azure Database for MySQL trigger binds to MySqlChangeProduct[], which is an array of MySqlChangeProduct objects. Each object has two properties:

• item: The item that was changed. The type of the item should follow the table schema, as seen in the Product class.
• operation: A value from the MySqlChangeOperation enumeration. The possible value is Update for both inserts and updates.

The following example shows a Java function that's invoked when changes occur in the Product table:

/**
 * Copyright (c) Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See License.txt in the project root for
 * license information.
 */

package com.function;

import com.microsoft.azure.functions.ExecutionContext;
import com.microsoft.azure.functions.annotation.FunctionName;
import com.microsoft.azure.functions.mysql.annotation.MySqlTrigger;
import com.function.Common.MySqlChangeProduct;
import com.google.gson.Gson;

import java.util.logging.Level;

public class ProductsTrigger {
    @FunctionName("ProductsTrigger")
    public void run(
            @MySqlTrigger(
                name = "changes",
                tableName = "Products",
                connectionStringSetting = "MySqlConnectionString")
                MySqlChangeProduct[] changes,
            ExecutionContext context) {

        context.getLogger().log(Level.INFO, "MySql Changes: " + new Gson().toJson(changes));
    }
}

More samples for the Azure Database for MySQL trigger are available in the GitHub repository.

The example refers to a Product database table:

DROP TABLE IF EXISTS Products;

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

You enable change tracking on the database by adding one column to the table:

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

The Azure Database for MySQL trigger binds to Product, which lists objects. Each object has two properties:

• item: The item that was changed. The structure of the item follows the table schema.
• operation: The possible value is Update for both inserts and updates.

The following example shows a PowerShell function that's invoked when changes occur in the Product table.

The following example is binding data in the function.json file:

{
    "bindings": [
      {
        "name": "changes",
        "type": "mysqlTrigger",
        "direction": "in",
        "tableName": "Products",
        "connectionStringSetting": "MySqlConnectionString"
      }
    ],
    "disabled": false
  }

The Configuration section explains these properties.

The following example is sample PowerShell code for the function in the run.ps1 file:

using namespace System.Net

param($changes)
# The output is used to inspect the trigger binding parameter in test methods.
# Use -Compress to remove new lines and spaces for testing purposes.
$changesJson = $changes | ConvertTo-Json -Compress
Write-Host "MySql Changes: $changesJson"

More samples for the Azure Database for MySQL trigger are available in the GitHub repository.

The example refers to a Product database table:

DROP TABLE IF EXISTS Products;

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

You enable change tracking on the database by adding one column to the table:

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

The Azure Database for MySQL trigger binds to Changes, which is an array of objects. Each object has two properties:

• item: The item that was changed. The structure of the item follows the table schema.
• operation: The possible value is Update for both inserts and updates.

The following example shows a JavaScript function that's invoked when changes occur in the Product table.

The following example is binding data in the function.json file:

{
    "bindings": [
      {
        "name": "changes",
        "type": "mysqlTrigger",
        "direction": "in",
        "tableName": "Products",
        "connectionStringSetting": "MySqlConnectionString",
      }
    ],
    "disabled": false
  }

The Configuration section explains these properties.

The following example is sample JavaScript code for the function in the index.js file:

module.exports = async function (context, changes) {
    context.log(`MySql Changes: ${JSON.stringify(changes)}`)
}

More samples for the Azure Database for MySQL trigger are available in the GitHub repository.

The example refers to a Product database table:

DROP TABLE IF EXISTS Products;

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

You enable change tracking on the database by adding one column to the table:

ALTER TABLE <table name>  
ADD COLUMN az_func_updated_at TIMESTAMP 
DEFAULT CURRENT_TIMESTAMP 
ON UPDATE CURRENT_TIMESTAMP;

The Azure Database for MySQL trigger binds to a variable named Product, which lists objects. Each object has two properties:

• item: The item that was changed. The structure of the item follows the table schema.
• operation: The possible value is Update for both inserts and updates.

The following example shows a Python function that's invoked when changes occur in the Product table.

import json
import logging
import azure.functions as func

app = func.FunctionApp()

# The function is triggered when a change (insert, update)
# is made to the Products table.
@app.function_name(name="ProductsTrigger")
@app.mysql_trigger(arg_name="products",
table_name="Products",
connection_string_setting="MySqlConnectionString")

def products_trigger(products: str) -> None:
logging.info("MySQL Changes: %s", json.loads(products))

{
    "bindings": [
      {
        "name": "changes",
        "type": "mysqlTrigger",
        "direction": "in",
        "tableName": "Products",
        "connectionStringSetting": "MySqlConnectionString"
      }
    ],
    "disabled": false
  }

import json
import logging

def main(changes):
    logging.info("MySql Changes: %s", json.loads(changes))

In the Java functions runtime library, use the @MySQLTrigger annotation on parameters whose values would come from Azure Database for MySQL. This annotation supports the following elements:

The following table explains the binding configuration properties that you set in the function.json file: