Structural search and replace

Search tools

A variable is a set of characters that are enclosed in dollar signs (for example, $tag$ or $anyCharactersYouWant$). A variable without filters and context equals a whole statement.

Filters are user-defined conditions for variables and search templates. By using filters, you can check a variable against a number of occurrences, check the value type, match the variable against plain text or a regular expression, and apply a Groovy script. See the full list of filters in Search templates, modifiers, and script constraints.

If we apply the type filter with the [string] value, we will find all the string values in our SELECT statements. But to find all the string types in the table definition (the CREATE TABLE statement), you need to apply the types context. To set context, you also use filters. But in contrast to variables, where the filter is applied to a specific variable, context filters are applied to the whole search template.

Contexts are built-in internal templates that help the search engine identify the variable. Contexts are used only for SQL to eliminate language ambiguities. By using context, you can tell the search engine where and what variable to search. You can set the following contexts for search templates:

• expressions: one or more values, operators, or SQL functions that result in to a value. With the expressions context, IDE will look for $expression_1$ and $expression_2$ in structures like SELECT $expression_1$ FROM table_name where $expression_2$.

• types: the type of value that can be stored in a table column (for example, varchar(100)). With the types context, IDE will look for $type_1$ and $type_2$ in structures like CREATE TABLE table_name (id_1 $type_1$, id_2 $type_2$).

• query clauses: query clauses like DISTINCT, FROM, WHERE, ORDER BY, GROUP BY, or HAVING. In the query clauses context, you need to use a clause keyword with a variable. For example, the IDE will look for where $variables$ in structures like select * from table_name $variables$;. If you have an expression like a + b in the WHERE clause, you can specify your variables explicitly like where $variable_1$ + $variable_2$;. And define any variable as a search target.

The Search target is a list in which you can specify what part of your template the IDE should search: a single variable or the whole template. For example, you can use search targets to find the $b$ value from the where $a$ + $b$ search template with context = query clause.

The Scope defines sources of information where you want to perform your search. It can be open or current files, directories in the Files tool window Alt+2, recently changed files, and other sources. To search in the specific directory, select Directory, press the Browse button.

The File type defines dialects of files in which you want to search.

How do SQL templates for structural search work

Let's see how the search engine processes search templates. Consider that you have the WHERE $a$ search template in the search field, and you set context = query clause.

1. DataGrip takes the definition of the query clauses context template. For the query clauses context template, the definition is SELECT id from dummy $pattern$. You can see all existing context templates under the Existing Templates menu item.

2. The IDE replaces the $pattern$ variable with the value that you defined in the search template. In our case, it is WHERE $a$. The replacement result will look like: SELECT id from dummy WHERE $a$.

3. The IDE parses the final SELECT statement and searches for WHERE $a$ in the syntax tree.

4. When WHERE $a$ is found, the IDE highlights it in the editor.

Search and replace structurally

Operations with search templates