In enterprise architectures where client applications interact with a business logic layer that then communicates with SQL Server, the CAL (Client Access License) requirements become non-trivial. Microsoft's licensing documentation states that CALs are required for "each user or device that accesses or uses the SQL Server software".

When implementing a three-tier architecture:

Clients → Business Logic Server → SQL Server

The critical determination point is whether the business logic server acts as:

• A multiplexing/pooling gateway (requires user/device CALs for all clients)
• A true application server transforming client requests (may qualify for per-server CAL)

The SQL Server 2022 licensing guide specifically addresses this scenario:

"If middleware or any other software (multi-tiered architecture) pools connections or multiplexes client access, you must license all users/devices that access the middleware as if they were direct SQL Server users."

The licensing outcome depends on how you architect the connection handling:

Scenario 1: Connection Pooling (Requires User CALs)

// ASP.NET Core example showing problematic pooling
services.AddDbContextPool<AppDbContext>(options => 
    options.UseSqlServer(Configuration.GetConnectionString("Default")));

Scenario 2: Isolated Server-to-Server (May Qualify for Server CAL)

// Service broker pattern that maintains dedicated connection
public class BusinessService : IBusinessService
{
    private readonly SqlConnection _dedicatedConnection;
    
    public BusinessService(string connString)
    {
        _dedicatedConnection = new SqlConnection(connString);
        _dedicatedConnection.Open();
    }
    
    public DataTable ExecuteBusinessLogic()
    {
        // All queries execute through single dedicated connection
        using var cmd = new SqlCommand("usp_TransformData", _dedicatedConnection);
        // ...
    }
}

To properly evaluate your licensing needs:

1. Run SQL Server Profiler to identify actual connection patterns
2. Document whether client context is preserved (via EXECUTE AS or similar)
3. Verify if connection strings contain client-specific identifiers

For high-client-count scenarios, consider:

• SQL Server per-core licensing (unlimited users)
• Azure SQL Database (DTU/vCore models)
• Moving business logic to SQL CLR (changes licensing dynamics)

These code patterns help maintain compliance:

// Claims-based isolation pattern
public async Task<IActionResult> GetData()
{
    var user = HttpContext.User;
    using var conn = new SqlConnection(_config.GetConnectionString("Direct"));
    await conn.OpenAsync();
    
    // Explicitly set context for auditing
    await using var cmd = new SqlCommand(
        "EXECUTE AS LOGIN = @user; EXEC usp_GetUserData; REVERT;", 
        conn);
    cmd.Parameters.AddWithValue("@user", user.Identity.Name);
    
    // ... execute and return
}

When dealing with SQL Server licensing, there are two primary CAL (Client Access License) types:

// Example showing connection from business logic layer
using System.Data.SqlClient;

string connectionString = "Server=myBusinessServer;Database=myData;";
using (SqlConnection connection = new SqlConnection(connectionString))
{
    connection.Open();
    // Business logic processing here
}

The licensing complexity arises in multi-tier architectures where:

• Clients connect to a middle-tier application server
• The application server acts as the sole SQL Server client
• No direct SQL Server connections from end-user devices

In this case, Microsoft's licensing stance is that:

if (clientAccessesSystemThroughMiddleware) {
    // Each client still requires a CAL
    licenseRequired = true;
} else if (directConnectionOnly) {
    // Only the connecting device needs CAL
    licenseRequired = false;
}

According to Microsoft's Product Use Rights document:

"Each device or user that accesses the SQL Server software (directly or indirectly) must have a SQL Server CAL."

For most enterprise scenarios, consider:

• Per-user CALs when users access from multiple devices
• Per-processor licensing for unlimited access scenarios
• Device CALs for fixed workstations in manufacturing/kiosks