Azure Table Storage Documentation

Introduction to Azure Table Storage

Azure Table Storage is a NoSQL key-attribute data store that accepts unstructured, semi-structured, and structured data. It's ideal for applications that need a flexible schema and massive scale. Unlike SQL databases, Table Storage doesn't enforce relationships between entities, making it highly adaptable.

Key Concepts

Table: A collection of entities. Similar to a table in a relational database, but without a fixed schema.
Entity: A set of properties. Similar to a row in a database. An entity can have up to 252 properties (plus the PartitionKey and RowKey).
Property: A name-value pair. Similar to a column in a database. Properties can be of various data types, including strings, integers, and dates.
PartitionKey: A string that determines the entity's partition. Entities with the same PartitionKey are stored together within the same storage partition. This is crucial for scalability and performance.
RowKey: A string that uniquely identifies an entity within a partition. The combination of PartitionKey and RowKey must be unique for each entity.

Working with Azure Table Storage

Creating a Table

You can create a table using the Azure portal, Azure CLI, PowerShell, or programmatically using Azure Storage SDKs.

Note: Table names must conform to specific naming rules:

Must start with a letter.
Can only contain letters and numbers.
Must be 3 to 63 characters long.
Case-insensitive.

Inserting Entities

Entities are inserted into a table. Each entity requires a PartitionKey and a RowKey.

// Example using Azure Storage SDK for .NET
        CloudTable table = tableClient.GetTableReference("MyTableName");
        await table.CreateIfNotExistsAsync();

        // Create an entity
        DynamicTableEntity customer = new DynamicTableEntity("Sales", "987");
        customer.Properties.Add("Name", new EntityProperty("Walter Gordon"));
        customer.Properties.Add("Email", new EntityProperty(" walter@contoso.com"));
        customer.Properties.Add("PhoneNumber", new EntityProperty("425-555-1212"));

        // Insert the entity
        TableOperation insertOperation = TableOperation.Insert(customer);
        await table.ExecuteAsync(insertOperation);

Querying Entities

You can query entities using various filters based on partition, row, and property values.

# Example using Azure Storage SDK for Python
        from azure.cosmosdb.table.tableservice import TableService
        from azure.cosmosdb.table.models import EntityProperty

        table_service = TableService(account_name='your_storage_account_name', account_key='your_storage_account_key')

        # Query for entities in a specific partition
        entities = table_service.query_entities('MyTableName', "PartitionKey eq 'Sales'")

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

Updating and Deleting Entities

Entities can be updated or deleted based on their PartitionKey and RowKey.

Update Operations:

InsertOrReplace: Inserts the entity if it doesn't exist, or replaces it if it does.
InsertOrMerge: Inserts the entity if it doesn't exist, or merges it with the existing entity if it does.
Replace: Replaces an existing entity. Fails if the entity doesn't exist.
Merge: Merges an existing entity. Fails if the entity doesn't exist.

Delete Operation:

Deletes an existing entity. Fails if the entity doesn't exist.

Performance and Scalability

Table Storage is designed for massive scale. Understanding how PartitionKey affects data distribution is key to achieving optimal performance.

Partitioning: Entities with the same PartitionKey are stored together. Queries targeting a specific PartitionKey are very efficient.
RowKey: Within a partition, entities are ordered by RowKey. This allows for efficient range queries within a partition.
Hot Partition: Avoid having a single partition (e.g., with the same PartitionKey for all entities) become a bottleneck due to excessive traffic.

Use Cases

User data for applications
Address books
Device information
Any kind of structured data that doesn't require complex joins or relational integrity.

Choosing PartitionKeys

The choice of PartitionKey significantly impacts performance and scalability. Design your PartitionKey strategy carefully:

Distribute load: Use different PartitionKey values for different types of data or users to spread operations across multiple partitions.
Enable efficient queries: Group related data under the same PartitionKey if you frequently query that data together.

Pricing

Azure Table Storage pricing is based on data storage, number of transactions, and data egress.

For detailed pricing information, please refer to the Azure Table Storage pricing page.