Table Storage Bindings

Table storage is a NoSQL key-attribute store that you can use to store large amounts of structured, non-relational data. Azure Functions provides input and output bindings for interacting with Azure Table Storage, simplifying the process of reading from and writing to tables.

Supported Operations

The table storage bindings for Azure Functions enable you to:

• Input Binding: Retrieve a single entity or a collection of entities from a table based on a partition key and row key, or a query.
• Output Binding: Insert or update entities in an Azure Table Storage table.

Configuration

To use the table storage bindings, you need to define them in your function.json file (for JavaScript, Python, and other non-.NET languages) or via attributes (for C#/.NET).

function.json Example (JavaScript)

{
  "scriptFile": "index.js",
  "bindings": [
    {
      "name": "inputTable",
      "type": "table",
      "direction": "in",
      "tableName": "products",
      "partitionKey": "{partitionKey}",
      "rowKey": "{rowKey}",
      "connection": "AzureWebJobsStorage"
    },
    {
      "name": "outputTable",
      "type": "table",
      "direction": "out",
      "tableName": "products",
      "connection": "AzureWebJobsStorage"
    },
    {
      "name": "req",
      "type": "httpTrigger",
      "direction": "in",
      "methods": [
        "get",
        "post"
      ]
    },
    {
      "name": "res",
      "type": "http",
      "direction": "out"
    }
  ]
}
            

using Microsoft.Azure.WebJobs.Extensions.Http;
using Microsoft.Azure.WebJobs.Extensions.Tables;
using Microsoft.Azure.WebJobs;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using System.Threading.Tasks;
using System.Collections.Generic;

public static class TableStorageExample
{
    [FunctionName("GetProduct")]
    public static IActionResult GetProduct(
        [HttpTrigger(AuthorizationLevel.Function, "get", Route = "product/{partitionKey}/{rowKey}")] HttpRequest req,
        string partitionKey,
        string rowKey,
        [Table("products", "{partitionKey}", "{rowKey}", Connection = "AzureWebJobsStorage")] Product product,
        ILogger log)
    {
        if (product == null)
        {
            return new NotFoundResult();
        }
        return new OkObjectResult(product);
    }

    [FunctionName("SaveProduct")]
    public static async Task SaveProduct(
        [HttpTrigger(AuthorizationLevel.Function, "post", Route = "product")] Product product,
        [Table("products", Connection = "AzureWebJobsStorage")] IAsyncCollector products,
        HttpRequest req,
        ILogger log)
    {
        await products.AddAsync(product);
        return new OkResult();
    }
}

public class Product
{
    public string PartitionKey { get; set; }
    public string RowKey { get; set; }
    public string Name { get; set; }
    public decimal Price { get; set; }
}
            

import logging
import azure.functions as func

def main(req: func.HttpRequest,
         inputTable: func.Out[func.InputStream],
         outputTable: func.Out[func.TableEntity],
         TableInput: func.InputStream) -> func.HttpResponse:
    logging.info('Python HTTP trigger function processed a request.')

    # Example: Reading from input table binding
    if TableInput:
        logging.info(f'Table entry: {TableInput.read().decode()}')

    # Example: Writing to output table binding
    try:
        req_body = req.get_json()
    except ValueError:
        pass
    else:
        partitionKey = req_body.get('partitionKey')
        rowKey = req_body.get('rowKey')
        name = req_body.get('name')
        price = req_body.get('price')

        if partitionKey and rowKey and name and price is not None:
            outputTable.set(func.TableEntity(
                partitionKey=partitionKey,
                rowKey=rowKey,
                name=name,
                price=float(price)
            ))
            return func.HttpResponse(
                 "Product saved successfully.",
                 status_code=200
            )

    return func.HttpResponse(
         "Please pass a product object in the request body",
         status_code=400
    )
            

Input Binding Details

The input binding allows you to fetch data from a table. You can specify the tableName, partitionKey, and rowKey. If you omit rowKey, the binding attempts to fetch all entities for the given partitionKey.

Properties:

• name: The name of the variable that will hold the retrieved entity or entities in your function code.
• type: Must be table.
• direction: Must be in.
• tableName: The name of the table to read from.
• partitionKey: The partition key to filter by. Can be a literal string or a dynamic value from the trigger or other input bindings (e.g., "{queueTrigger}").
• rowKey: The row key to filter by. Can be a literal string or a dynamic value. If omitted, all entities for the partition key are returned.
• connection: The name of the app setting that contains the Azure Storage connection string. Defaults to AzureWebJobsStorage.

Output Binding Details

The output binding is used to insert or update entities in a table. You typically use a collector object (like IAsyncCollector<TEntity> in C# or func.Out[func.TableEntity] in Python) to add entities.

Properties:

• name: The name of the variable used to interact with the output binding in your function code.
• type: Must be table.
• direction: Must be out.
• tableName: The name of the table to write to.
• connection: The name of the app setting that contains the Azure Storage connection string. Defaults to AzureWebJobsStorage.

Entity Structure

Entities in Azure Table Storage consist of a PartitionKey, a RowKey, and a set of named properties. The PartitionKey and RowKey together form the unique identifier for an entity.

Property	Type	Description
PartitionKey	String	Required. Used for partitioning data.
RowKey	String	Required. Unique within a partition.
Timestamp	DateTime	Automatically managed by Azure Table Storage.
Custom Properties	Various (String, Int, Double, Boolean, DateTime, Guid, Binary)	User-defined data properties.

Example Usage

Here's a conceptual example of how you might use the bindings to retrieve a product by its ID and then update its price:

// index.js (simplified)
module.exports = async function (context, req, inputTable) {
    context.log('JavaScript HTTP trigger function processed a request.');

    const partitionKey = req.query.partitionKey || req.body.partitionKey;
    const rowKey = req.query.rowKey || req.body.rowKey;
    const newPrice = req.body.price;

    if (!partitionKey || !rowKey) {
        context.res = { status: 400, body: "Please provide partitionKey and rowKey." };
        return;
    }

    // inputTable contains the entity if found, or null
    if (inputTable) {
        context.log(`Found product: ${inputTable.name} - $${inputTable.price}`);

        if (newPrice !== undefined) {
            // Using output binding to update
            context.bindings.outputTable = {
                PartitionKey: partitionKey,
                RowKey: rowKey,
                name: inputTable.name, // Keep existing name
                price: newPrice
            };
            context.res = { body: "Product price updated successfully." };
        } else {
            context.res = { body: inputTable };
        }
    } else {
        context.res = { status: 404, body: "Product not found." };
    }
};
            

Troubleshooting

• Ensure your connection string in appsettings.json or environment variables is correct and points to a valid Azure Storage account.
• Verify that the tableName specified in your binding configuration exists in your storage account.
• Check that the partitionKey and rowKey you are using are valid and exist in your table.
• For dynamic keys (e.g., from HTTP parameters or queue messages), ensure the parameter names match exactly.