Programmatically Searching All Tables in SQL Server for a String


Identifying Tables:

  • We'll use the sys.tables system procedure to get a list of all tables in the current database.

Looping Through Tables:

  • We'll use a loop to iterate through each table retrieved from sys.tables.

Building Dynamic SQL (Optional):

  • Inside the loop, we can construct a dynamic SQL statement to search each table's text columns for the specific string. This allows you to specify the column names containing text data.

Searching Each Table:

  • Execute the dynamic SQL statement (or a predefined static query for all text columns) to search for the string in that particular table.

Capturing Results:

  • Capture the results from each table execution, storing information like table name, column name (if applicable), and the row where the string was found.

Important Considerations:

  • This approach can be slow for large databases with many tables.
  • Be cautious with dynamic SQL to prevent potential security vulnerabilities like SQL injection.


  • Consider using full-text search features in SQL Server if available in your version. This can be a more performant option for searching large amounts of text data.

Using Cursors (Less performant, but simpler):

DECLARE @search_string VARCHAR(100) = 'YourSearchString';

DECLARE @table_schema SYSNAME,
        @table_name SYSNAME,
        @column_name SYSNAME,
        @sql_string NVARCHAR(MAX);

OPEN tables_cur CURSOR FOR

FETCH NEXT FROM tables_cur INTO @table_schema, @table_name;

  OPEN columns_cur CURSOR FOR
    WHERE TABLE_SCHEMA = @table_schema
      AND TABLE_NAME = @table_name
      AND DATA_TYPE IN ('nvarchar', 'varchar', 'nchar', 'char');

  FETCH NEXT FROM columns_cur INTO @column_name;

    SET @sql_string = 'SELECT * FROM ' + QUOTENAME(@table_schema) + '.' + QUOTENAME(@table_name) + ' WHERE ' + QUOTENAME(@column_name) + ' LIKE ''%' + @search_string + '%'';

    -- Execute the search query here (replace with your logic to handle results)
    -- EXEC sp_executesql @sql_string;

    FETCH NEXT FROM columns_cur INTO @column_name;
  CLOSE columns_cur;
  DEALLOCATE columns_cur;

  FETCH NEXT FROM tables_cur INTO @table_schema, @table_name;

CLOSE tables_cur;
DEALLOCATE tables_cur;

Using sp_executesql (More performant, but requires building dynamic SQL):

  @search_string NVARCHAR(MAX)

  SELECT @sql = @sql + 'SELECT ''[' + + ''].[' + + ']'' AS Location, * 
  FROM ' + QUOTENAME( + '.' + QUOTENAME( + ' 
  WHERE ' + QUOTENAME( + ' LIKE ''%' + @search_string + '%'' 

  FROM sys.schemas AS s
  INNER JOIN sys.tables AS t ON s.schema_id = t.schema_id
  INNER JOIN sys.columns AS c ON t.object_id = c.object_id
  WHERE c.system_type_id IN (35, 167, 175);

  -- Remove the trailing UNION ALL
  SET @sql = SUBSTRING(@sql, 0, LEN(@sql) - 11);

  -- Execute the dynamic SQL
  EXEC sp_executesql @sql, N'@search NVARCHAR(MAX)', @search_string;

-- Call the procedure with your search string
EXEC SearchAllTables 'YourSearchString';


  • Replace 'YourSearchString' with the actual string you want to search for.
  • The first example uses cursors which can be slow for large databases.
  • The second example builds dynamic SQL which requires caution to avoid security vulnerabilities.

Full-Text Search (if available):

  • If your SQL Server version supports full-text search, it can be a much faster and more efficient way to search large amounts of text data.
  • You'll need to create a full-text index on the relevant tables and columns containing text data.
  • Then, you can use dedicated full-text search functions like CONTAINS to find the string within the indexed data.

Information Schema Views:

  • You can leverage system views from INFORMATION_SCHEMA like COLUMNS and TABLES to build a static SQL query that searches all text columns in your database.
  • This approach avoids dynamic SQL but requires manually specifying the text data types (e.g., nvarchar, varchar) in the query.

Third-Party Tools:

  • Several third-party tools and scripts specifically designed for searching SQL Server databases can be used.
  • These tools often provide additional features like filtering by schema or specific tables, reporting results, and potentially offering better performance for large-scale searches.

Here's a brief comparison of the methods:

CursorsSimpler to understandLess performant for large databases, uses dynamic SQL
sp_executesqlMore performant, avoids cursorsRequires careful handling of dynamic SQL for security
Full-Text SearchHighly performant for large text dataRequires full-text indexing setup
Information Schema ViewsAvoids dynamic SQL, potentially faster than cursorsRequires manual specification of data types
Third-Party ToolsAdditional features, potentially better performanceMay require additional cost or setup

Choosing the right method depends on your specific needs:

  • If performance is critical for a large database, consider full-text search or third-party tools.
  • If you need a simple solution and understand the security risks, cursors or sp_executesql might suffice for smaller databases.
  • Information schema views offer a balance between simplicity and performance for static searches.

sql sql-server search

Storing Stored Procedures and DB Schema in Source Control

Stored procedures: Precompiled SQL code stored in a database that performs a specific task.DB schema: The structure of a database...

Bridging the Language Gap: Effective Database Design for Multilingual Applications

Understanding the ChallengeWhen your database needs to store and manage data in multiple languages, you face the challenge of efficiently storing translations and retrieving the correct information based on a user's preferred language...

Optimizing Date Manipulation: Extracting Year and Month in PostgreSQL

Using the EXTRACT function:EXTRACT allows you to retrieve specific parts from a date or timestamp.To get the year, use EXTRACT(YEAR FROM your_date_column)...

Efficient Pagination with Total Count in PostgreSQL (Subquery with Window Function)

Scenario:You want to retrieve a specific subset of data from a large table while also knowing the total number of rows in the table...

MySQL Query Performance: Indexing Strategies for Boolean and Datetime Data

Scenario:You have a MySQL table with columns for storing data: A Boolean column (typically TINYINT(1)) representing a true/false flag (e.g., is_active) A Datetime column for storing timestamps (e.g., created_at)...

sql server search

Unveiling Hidden Data: Exploring Methods for Comprehensive Value Search in SQL Server

Here's how programmers typically achieve this functionality:Using Cursors and Temporary Tables: A program block called a cursor loops through all tables in the database