QueryLens 1.0.0-preview.1

QueryLens

Validate your raw SQL at test time — not runtime.

QueryLens catches column typos, missing parameters, invalid functions, and dialect mistakes in your SQL before they hit production. Built for Dapper, ADO.NET, and any .NET code with hand-written SQL.

Why?

SQL queries in .NET are opaque strings. The compiler can't see them. A typo in a column name, a function that doesn't exist in your SQL Server version, a table that was renamed last week — you won't know until runtime. QueryLens fixes that.

Quick Start

dotnet add package QueryLens

1. Check for syntax errors

var query = new SqlQuery("SELECT * FROM customers WHERE created_date >= GETDATE()");

var result = SqlValidator.UseSqlServer().Validate(query);

Assert.True(result.IsValid);   // passes — valid T-SQL

That's it. One query, one validator, one assert.

2. Check for version-specific function errors

STRING_AGG was introduced in SQL Server 2017. If your production server runs 2014:

var query = new SqlQuery("SELECT STRING_AGG(name, ',') FROM departments");

var result = SqlValidator.UseSqlServer()
    .ServerVersion("2014")
    .AllowCustomFunctions(false)
    .Validate(query);

Assert.False(result.IsValid);
// QL0071: Function 'STRING_AGG' is not available in SQL Server version 2014.

3. Check for tables and columns that don't exist

var query = new SqlQuery("SELECT id, full_name, email FROM customers");

var result = SqlValidator.UseSqlServer()
    .WithSchema(s => s
        .Table("customers")
            .Column("id", SqlType.Int)
            .Column("name", SqlType.NVarChar)
            .Column("email", SqlType.NVarChar))
    .Validate(query);

Assert.False(result.IsValid);
// QL0011: Column 'full_name' does not exist in table 'customers'.

4. Check for missing parameters

var query = new SqlQuery("SELECT * FROM orders WHERE status = @Status AND id = @Id");

var result = SqlValidator.UseSqlServer()
    .Build()
    .Validate(query, new { Status = "active" });   // @Id is missing

Assert.False(result.IsValid);
// QL0030: SQL parameter '@Id' has no matching value in the provided parameters.

5. Catch identity column violations

var insert = new SqlInsert("INSERT INTO customers (id, name) VALUES (@Id, @Name)");

var result = SqlValidator.UseSqlServer()
    .WithSchema(s => s
        .Table("customers")
            .Column("id", SqlType.Int, isIdentity: true)
            .Column("name", SqlType.NVarChar))
    .Validate(insert);

Assert.False(result.IsValid);
// QL0060: Column 'id' is an identity column and cannot be explicitly set.

6. Warn on dangerous deletes

var delete = new SqlDelete("DELETE FROM customers");

var result = SqlValidator.UseSqlServer().Validate(delete);

Assert.Contains(result.Warnings, w => w.Code == "QL0040");
// QL0040: DELETE statement without WHERE clause.

Configure Once, Validate Everywhere

Set up your validator once at startup. Then every query validates itself:

// Call once — in an xUnit fixture, [ModuleInitializer], or test base class
QueryLensConfig.Configure(b =>
{
    b.UseSqlServer();
    b.WithSchema(s => s
        .Table("customers")
            .Column("id", SqlType.Int, isIdentity: true)
            .Column("name", SqlType.NVarChar)
            .Column("email", SqlType.NVarChar));
});

// Now every query validates itself
var query = new SqlQuery("SELECT id, name FROM customers");
Assert.True(query.IsValid);

var bad = new SqlQuery("SELECT id, phone FROM customers");
Assert.False(bad.IsValid);
// bad.ErrorSummary → "Column 'phone' does not exist in table 'customers'."

Works With Every Major SQL Dialect

SqlValidator.UseSqlServer()    // T-SQL: TOP, ISNULL, [brackets]
SqlValidator.UsePostgreSql()   // PG: LIMIT/OFFSET, COALESCE, "double quotes"
SqlValidator.UseMySql()        // MySQL: LIMIT, IFNULL, `backticks`
SqlValidator.UseSqlite()       // SQLite: LIMIT, lightweight functions
SqlValidator.UseOracle()       // Oracle: ROWNUM, NVL, DUAL

Each dialect ships with a complete JSON catalog of built-in functions (with version tags), commands, reserved words, and deprecated keywords.

Type System

QueryLens provides typed SQL wrappers. They implicitly convert to string, so they drop in wherever Dapper expects SQL:

// These just work with Dapper — no .Text or .ToString()
await connection.QueryAsync<Customer>(myQuery, new { Status = "active" });
await connection.ExecuteAsync(myInsert, new { Name = "Acme" });

Validation Rules

Every rule is independently toggleable. Start simple, enable more as your team is ready:

var validator = SqlValidator.UseSqlServer()
    .Enable(Rules.ValidateRequiredColumns)
    .Disable(Rules.ValidateBuiltInFunctions)
    .Build();

Issue Codes

Performance

Fast enough to validate your entire query catalog on every build:

What QueryLens Is Not

• Not an ORM — it doesn't generate SQL or map results
• Not a query optimizer — it doesn't suggest indexes
• Not a migration tool — it doesn't apply schema changes
• Not a runtime validator — all validation is static, at test time

License

MIT