Searching for text across multiple tables in SQL Server

Discover how to execute a comprehensive text search across multiple tables in SQL Server with our expertly crafted T-SQL script. Learn its implementation, benefits, and limitations.

Setting the Stage: The Need for Text Search in SQL Server

In many database-driven applications, there comes a time when you need to search for specific text across multiple tables and columns. 

This task can be particularly challenging when dealing with large databases or when the database schema is complex or unknown.

To address this challenge, I've developed a T-SQL script that searches for a specified string across various text-based data types in an SQL Server database.

Demystifying the T-SQL Script: Purpose and Use Cases

The purpose of our script is straightforward: to search for a given text string across all tables and specific column types in a SQL Server database.

This is particularly useful in cases where you're unsure of the exact location of specific data or when you need to perform a global search – for instance, finding all instances of a customer's name or a particular keyword.

In-Depth Analysis: Dissecting the T-SQL Search Script

Here’s the T-SQL that searches for a specific string in all text-based columns across the MSSQL database.

You need to adjust the data types, schema, and search string as needed for your specific requirements.

DECLARE @TargetString VARCHAR(255) = 'Piotr Bach' -- The text string to search for
DECLARE @CurrentSchemaName NVARCHAR(255) = 'dbo' -- The name of the current schema being processed
DECLARE @CurrentTableName NVARCHAR(255)  -- The name of the current table being processed
DECLARE @CurrentColumnName NVARCHAR(255) -- The name of the current column being processed
DECLARE @DynamicSQL NVARCHAR(MAX)        -- Dynamic SQL command to be constructed and executed

-- Cursor to iterate through all relevant tables and columns
    WHERE DATA_TYPE IN ('varchar', 'char', 'text', 'nvarchar', 'ntext', 'varbinary') -- Include appropriate data types
    AND TABLE_SCHEMA = @CurrentSchemaName

OPEN ColumnCursor

FETCH NEXT FROM ColumnCursor INTO @CurrentSchemaName, @CurrentTableName, @CurrentColumnName

    -- Construct the SQL query for the current column
    SET @DynamicSQL = 'SELECT * FROM [' + @CurrentSchemaName + '].[' + @CurrentTableName + '] WHERE [' + @CurrentColumnName + '] LIKE ''%' + @TargetString + '%'''
    -- Execute the dynamic SQL
    EXEC sp_executesql @DynamicSQL

    -- Print the dynamic SQL for debugging purposes
    PRINT('Executed search for "' + @TargetString + '" in schema [' + @CurrentSchemaName + '], table [' + @CurrentTableName + '], column [' + @CurrentColumnName + '].')

    FETCH NEXT FROM ColumnCursor INTO @CurrentSchemaName, @CurrentTableName, @CurrentColumnName

CLOSE ColumnCursor

Please test this script in a development or staging environment before running it in production, especially considering the potential performance impact on large databases.

Also, adjust the data types in the cursor's WHERE clause according to your database's specific needs and schema.

Here is a fragment of possible output:

(1 row affected)
Executed search for "Piotr Bach" in schema [dbo], table [umbracoUser], column [userName].

(510 rows affected)
Executed search for "Piotr Bach" in schema [dbo], table [umbracoAudit], column [performingDetails].

(902 rows affected)
Executed search for "Piotr Bach" in schema [dbo], table [umbracoAudit], column [affectedDetails].
Searching for target string via T-SQL in MSSQL database

Core Concepts: Cursors, Dynamic SQL, and Data Types


The script uses a cursor to iterate through the INFORMATION_SCHEMA.COLUMNS view, which provides information about each column in the database.

Cursors are ideal for this row-by-row processing but should be used judiciously due to potential performance impacts.

Dynamic SQL

The script constructs a SQL query as a string (dynamic SQL) for each column that meets the criteria.

Dynamic SQL is powerful for constructing flexible queries but must be used carefully to avoid SQL injection risks.

Data Type Consideration

We have included various text-based data types in the script.

This ensures the script can be applied to different tables regardless of their specific column data types.

Weighing the Advantages and Drawbacks of the Script


  • Comprehensive Coverage: The script searches through all text-based columns in all tables, ensuring no location is missed.
  • Adaptability: It can be easily modified for search terms or column types.
  • Dynamic Applicability: The script handles varying table and column structures, making it highly versatile.


  • Performance Overhead: The script can be slow on large databases and may impact performance due to its comprehensive nature.
  • Cursor Usage: Cursors are generally less efficient than set-based operations in SQL.
  • Injection Risks: Care must be taken to avoid SQL injection vulnerabilities in dynamic SQL.

Concluding Insights: Balancing Functionality and Performance in SQL Server

This T-SQL script is a handy tool for database administrators and developers who must perform a text search across multiple tables in SQL Server.

While it offers comprehensive search capabilities and adaptability, it's essential to use it judiciously, particularly in large or production environments, due to its potential performance implications.

Always test the script in a controlled environment before deploying it in a live database.

Effective database management is about finding the right balance between functionality and performance.

The above script can be a valuable addition to your SQL toolkit with careful use, and it's available on GitHub.

🌐 Explore More: Interested in learning about SQL and web development insights?

Explore our blog for a wealth of information and expert advice.

↑ Top ↑