Azure Storage Tables Documentation

Introduction to Azure Table Storage

Azure Table Storage is a NoSQL key-attribute store that accepts un-typed data. It's designed for storing large amounts of structured, non-relational data that can be queried without complex joins. Table Storage is an excellent choice for web applications that need a flexible schema for storing datasets like user data, address books, or device information.

Getting Started

To start using Azure Table Storage, you need an Azure Storage account. Once you have an account, you can interact with Table Storage using the Azure SDKs, REST APIs, or Azure CLI.

Create an Azure Storage Account.
Choose your preferred SDK (e.g., .NET, Python, Java, Node.js).
Connect to your storage account using your connection string.

Core Concepts

Tables

A table is a collection of entities. Tables do not enforce a schema, meaning that different entities within the same table can have different sets of properties.

Entities

An entity is a record within a table, conceptually similar to a row in a relational database. Each entity can have up to 252 properties, in addition to the system properties: PartitionKey, RowKey, Timestamp, and ETag.

Properties

Properties are name-value pairs within an entity. Property names are strings, and values can be of various primitive data types (e.g., String, Int32, Int64, Boolean, Double, DateTime, GUID, Binary, DateTimeOffset).

PartitionKey and RowKey

Every entity in Azure Table Storage must have two system properties that together form its unique identifier: PartitionKey and RowKey.

PartitionKey: Entities with the same PartitionKey are co-located on the same storage node, which optimizes query performance for entities within the same partition.
RowKey: Within a partition, the RowKey uniquely identifies an entity. It must be unique within its partition.

The combination of PartitionKey and RowKey must be unique for each entity in the table.

Best Practice: Design your PartitionKey and RowKey to optimize your common query patterns. For heavily queried data, ensure that related entities share the same PartitionKey.

Data Modeling

Table Storage excels at handling rapidly growing datasets. When modeling your data, consider these points:

Denormalization: Denormalization is often preferred over complex joins.
Partitioning Strategy: Distribute your data evenly across partitions to avoid hot partitions and ensure scalability.
Property Types: Use appropriate data types for your properties to optimize storage and querying.

Operations

Common operations include inserting, querying, updating, and deleting entities. Table Storage supports efficient querying using OData syntax.

Insert Entity

Adds a new entity to a table.

// Example using Azure SDK for Python
from azure.data.tables import TableServiceClient
from azure.data.tables.models import EdmType

CONNECTION_STRING = "YOUR_CONNECTION_STRING"
TABLE_NAME = "myEntities"

def insert_entity_example():
    table_service_client = TableServiceClient.from_connection_string(CONNECTION_STRING)
    table_client = table_service_client.get_table_client(table_name=TABLE_NAME)

    entity = {
        "PartitionKey": "users",
        "RowKey": "user1",
        "name": "Alice",
        "email": "alice@example.com",
        "age": 30
    }
    table_client.upsert_entity(entity)
    print("Entity inserted successfully.")

Query Entities

Retrieves entities from a table based on filter criteria.

# Example using Azure SDK for Python
def query_entities_example():
    # ... (previous setup code) ...

    filter_query = "name eq 'Alice'"
    entities = table_client.query_entities(filter_query)

    for entity in entities:
        print(f"Name: {entity.get('name')}, Email: {entity.get('email')}")

Update Entity

Modifies an existing entity.

# Example using Azure SDK for Python
def update_entity_example():
    # ... (previous setup code) ...

    entity = table_client.get_entity("users", "user1")
    entity["age"] = 31
    table_client.update_entity(entity, mode="Replace")
    print("Entity updated successfully.")

Delete Entity

Removes an entity from a table.

# Example using Azure SDK for Python
def delete_entity_example():
    # ... (previous setup code) ...

    table_client.delete_entity("users", "user1")
    print("Entity deleted successfully.")

SDK Examples

The Azure SDKs provide convenient abstractions for interacting with Table Storage. Visit the official SDK documentation for your preferred language for detailed examples and API references.

Pricing

Azure Table Storage pricing is based on the amount of data stored and the number of transactions performed. For detailed information, refer to the Azure Storage pricing page.

Best Practices

Design efficient PartitionKey and RowKey schemes.
Avoid creating "hot" partitions by distributing requests evenly.
Use batch operations for multiple entity modifications when possible.
Leverage Table Storage's schema flexibility.
Monitor your storage account for performance and usage.