Invalid column name – Complete Fix Guide

❌ Invalid column name SqlException / Entity Framework

Complete troubleshooting guide — understand why SQL Server (or EF Core) complains about a missing column, and fix it in your database, model, migrations, or queries.

📑 Table of Contents

01 What is this error? 02 Root Causes 03 Step‑by‑Step Fixes 04 Direct SQL / Stored Procedures 05 Entity Framework Core 06 Migrations & Schema Sync 07 ASP.NET Core & DTOs 08 Raw SQL & FromSql 09 Testing & In‑Memory 10 Prevention & Best Practices

❓ What is "Invalid column name"?

This error is thrown when you execute a SQL query (or an EF Core query that generates SQL) that references a column that does not exist in the underlying database table (or view) at the time of execution.

⚠️ Typical Error Messages

System.Data.SqlClient.SqlException: Invalid column name 'SomeColumn'.
-- or --
Microsoft.Data.SqlClient.SqlException: Invalid column name 'SomeColumn'.
-- or in EF Core --
System.InvalidOperationException: 'SomeColumn' is not a valid property name.

This can happen in many contexts: when using SqlCommand, LINQ queries, EF Core's FromSqlRaw, stored procedures, or even when EF Core tries to generate a migration. It’s a sign that your database schema and your code (or model) are out of sync.

🔍 Root Causes

Common causes include:

1️⃣ Typo in column name Most common

The column name in your query or model is misspelled or has a different case (if using case‑sensitive collation).

2️⃣ Column was renamed or dropped Schema change

The database was modified (via SQL script or manual) but your model or query wasn't updated.

3️⃣ EF Core model not aligned with database Migration missing

You added a property but forgot to create and apply a migration.

4️⃣ Using a column from a different table Join confusion

In a JOIN, you might reference a column that belongs to a table not included in the query.

5️⃣ Raw SQL with alias mismatch Alias issue

Using FromSqlRaw and projecting a column that doesn't exist in the result set.

6️⃣ Computed column or JSON property Complex types

JSON columns or computed columns may require special handling.

🛠️ Step‑by‑Step Fixes

Follow this process to resolve the error:

1 Verify the column exists in the database

Connect to your database (SQL Server Management Studio, Azure Data Studio, or SELECT * FROM INFORMATION_SCHEMA.COLUMNS) and check the exact column name.

2 Check for spelling and case

If your database uses a case‑sensitive collation, ensure the casing matches exactly.

3 Update your EF Core model or migration

If you added a property, run dotnet ef migrations add and dotnet ef database update.

4 Adjust your raw SQL or LINQ query

Rename the column reference to match the actual database column name.

5 Use column aliases in FromSqlRaw

If you use custom SQL, ensure the result set includes columns that map to your entity properties.

✅ Quick Tip

In Visual Studio, use the SQL Server Object Explorer to view the table columns. For EF Core, compare your model with the generated migration file.

📝 Direct SQL and Stored Procedures

If you're writing raw SQL or calling a stored procedure, the error is straightforward — the column doesn't exist in the table or view you're querying.

// ❌ Wrong – column 'FullName' doesn't exist using (var cmd = new SqlCommand("SELECT Id, FullName FROM Users", conn)) { ... } // ✅ Correct – use the actual column name (e.g., FirstName + LastName or a computed column) using (var cmd = new SqlCommand("SELECT Id, FirstName + ' ' + LastName AS FullName FROM Users", conn)) { ... }

For stored procedures, ensure the procedure returns a column with the expected name. You may need to use AS to alias the result.

💡 Tip

Always test your SQL queries directly in SSMS or Azure Data Studio before running them from code.

🧩 Entity Framework Core

In EF Core, this error often appears when you query an entity that has a property not mapped to a database column, or when the column name in the model doesn't match the database.

Model vs. Database column mismatch

// Entity public class Product { public int Id { get; set; } public string Name { get; set; } public decimal UnitPrice { get; set; } // ❌ column in DB might be 'Price' } // Fix: use Column attribute or fluent API [Column("Price")] public decimal UnitPrice { get; set; } // or in OnModelCreating: modelBuilder.Entity<Product>() .Property(p => p.UnitPrice) .HasColumnName("Price");

Missing property in migration

If you added a new property to your entity but forgot to create a migration, the column won't exist in the database. Run:

dotnet ef migrations add AddUnitPriceColumn dotnet ef database update

🔄 Migrations and Schema Synchronization

One of the most common causes is that your database schema is out of sync with your EF Core model. This can happen if:

• You manually changed the database without creating a migration.
• You have pending migrations that haven't been applied.
• You're using a different database environment (e.g., development vs. production).

Check pending migrations:

dotnet ef migrations list // If any are pending, apply them: dotnet ef database update

If you want to generate a migration that only adds the missing column, you can use the --no-build flag or --no-migrations when adding.

⚠️ Important

If you're in a team environment, ensure all team members have the same migrations applied. Use dotnet ef database update after pulling changes.

🌐 ASP.NET Core and DTO Mapping

Sometimes the error appears when you try to map a DTO property to a database column that doesn't exist, often when using Select or ProjectTo (AutoMapper).

// DTO with a property not present in the entity var result = await context.Products .Select(p => new ProductDto { FullName = p.FullName }) // ❌ Product doesn't have FullName .ToListAsync(); // ✅ Correct – use a computed property or map from existing columns .Select(p => new ProductDto { FullName = p.Name + " " + p.Description })

Also, when using FromSqlRaw with a DTO, ensure the SQL result set has columns that exactly match the DTO's property names (or use aliases).

⚡ Raw SQL with FromSqlRaw / FromSqlInterpolated

When you execute raw SQL and map it to an entity, the column names in the result set must match the entity's property names (unless you use column attributes).

// ❌ SQL returns 'Price', but entity expects 'UnitPrice' var products = await context.Products .FromSqlRaw("SELECT Id, Name, Price FROM Products") .ToListAsync(); // ✅ Fix – alias the column var products = await context.Products .FromSqlRaw("SELECT Id, Name, Price AS UnitPrice FROM Products") .ToListAsync(); // Or use a column attribute on the entity.

Also, ensure that the number of columns returned matches the number of properties you're mapping.

🧪 Testing and In‑Memory Database

When using the EF Core in‑memory provider for testing, you might encounter "Invalid column name" because the in‑memory database doesn't enforce schema the same way. However, if you're using the SQLite in‑memory provider or a real database, the error is real.

For tests, ensure your test database schema is up‑to‑date (e.g., use EnsureCreated or Migrate).

using (var context = new AppDbContext(options)) { context.Database.EnsureCreated(); // For in‑memory // or context.Database.Migrate(); for real DB }

🛡️ Prevention and Best Practices

✅ Use migrations for schema changes

Always use EF Core migrations to keep your database in sync with your models.

✅ Name your properties consistently

Match property names to column names, or use [Column] attributes to map.

✅ Avoid raw SQL when possible

Prefer LINQ queries, which are checked at compile time (though still need schema correctness).

✅ Use FromSql with alias carefully

If you must use raw SQL, always alias columns to match your entity properties.

✅ Test migrations in CI/CD

Automatically apply migrations during deployment to catch mismatches early.

✅ Use schema diff tools

Compare your model with the database using EF Core's EnsureCreated or third‑party tools.

🏆 Pro Tip

If you're in a microservices environment, consider using a database migration pipeline where migrations are applied before the new version of the service is deployed. This prevents "Invalid column name" errors when rolling out new features.

📚 This guide covers the most common causes and fixes for "Invalid column name" errors in SQL Server, EF Core, and ASP.NET Core.
🧑‍💻 Applicable to all .NET versions and database providers.
❤️ If this helped you, please share it with your team!