Comprehensive comparison for Database technology in Software Development applications

using Microsoft.Azure.Cosmos;
using System;
using System.Net;
using System.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;

public class ProductCatalogService
{
    private readonly Container _container;
    private const string DATABASE_NAME = "ECommerceDB";
    private const string CONTAINER_NAME = "Products";

    public ProductCatalogService(CosmosClient cosmosClient)
    {
        _container = cosmosClient.GetContainer(DATABASE_NAME, CONTAINER_NAME);
    }

    // Create or update a product with optimistic concurrency control
    public async Task<Product> UpsertProductAsync(Product product)
    {
        try
        {
            // Validate input
            if (string.IsNullOrEmpty(product.Id))
                throw new ArgumentException("Product ID is required");

            product.LastModified = DateTime.UtcNow;
            
            // Use partition key for efficient writes
            var response = await _container.UpsertItemAsync(
                item: product,
                partitionKey: new PartitionKey(product.Category),
                requestOptions: new ItemRequestOptions
                {
                    IfMatchEtag = product.ETag // Optimistic concurrency
                }
            );

            return response.Resource;
        }
        catch (CosmosException ex) when (ex.StatusCode == HttpStatusCode.PreconditionFailed)
        {
            throw new InvalidOperationException("Product was modified by another process", ex);
        }
        catch (CosmosException ex)
        {
            throw new Exception($"CosmosDB error: {ex.Message}", ex);
        }
    }

    // Query products with pagination and filtering
    public async Task<(List<Product> Products, string ContinuationToken)> GetProductsByCategoryAsync(
        string category, int pageSize = 20, string continuationToken = null)
    {
        try
        {
            var queryDefinition = new QueryDefinition(
                "SELECT * FROM c WHERE c.category = @category AND c.isActive = true ORDER BY c.price")
                .WithParameter("@category", category);

            var queryRequestOptions = new QueryRequestOptions
            {
                PartitionKey = new PartitionKey(category),
                MaxItemCount = pageSize
            };

            var iterator = _container.GetItemQueryIterator<Product>(
                queryDefinition,
                continuationToken,
                queryRequestOptions
            );

            var products = new List<Product>();
            string nextToken = null;

            if (iterator.HasMoreResults)
            {
                var response = await iterator.ReadNextAsync();
                products.AddRange(response.Resource);
                nextToken = response.ContinuationToken;
            }

            return (products, nextToken);
        }
        catch (CosmosException ex)
        {
            throw new Exception($"Error querying products: {ex.Message}", ex);
        }
    }

    // Transactional batch operation for inventory updates
    public async Task<bool> ProcessOrderAsync(string category, List<OrderItem> orderItems)
    {
        try
        {
            var batch = _container.CreateTransactionalBatch(new PartitionKey(category));

            foreach (var item in orderItems)
            {
                // Read current inventory
                var response = await _container.ReadItemAsync<Product>(
                    item.ProductId,
                    new PartitionKey(category)
                );

                var product = response.Resource;

                if (product.StockQuantity < item.Quantity)
                    throw new InvalidOperationException($"Insufficient stock for {product.Name}");

                product.StockQuantity -= item.Quantity;
                product.LastModified = DateTime.UtcNow;

                batch.ReplaceItem(item.ProductId, product, new TransactionalBatchItemRequestOptions
                {
                    IfMatchEtag = product.ETag
                });
            }

            var batchResponse = await batch.ExecuteAsync();
            return batchResponse.IsSuccessStatusCode;
        }
        catch (CosmosException ex)
        {
            throw new Exception($"Transaction failed: {ex.Message}", ex);
        }
    }
}

public class Product
{
    public string Id { get; set; }
    public string Category { get; set; } // Partition key
    public string Name { get; set; }
    public decimal Price { get; set; }
    public int StockQuantity { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastModified { get; set; }
    public string ETag { get; set; }
}

public class OrderItem
{
    public string ProductId { get; set; }
    public int Quantity { get; set; }
}