Limit non unique indexes in SQLAlchemy

postgresqlsqlalchemyalembicmigrations
Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',

Install this rule for wispbit

Add this rule to wispbit and it will run when you open a pull request

Install this rule for Coderabbit

Copy the configuration below and add it to your repository as .coderabbit.yml in your project root.

reviews:
  path_instructions:
    - path: "*.py"
      instructions: |
                
        Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
        
        Bad:
        
        ```python
        def upgrade():
            with op.get_context().autocommit_block():
                op.create_index(
                    'index_users_on_multiple_columns',
                    'users',
                    ['column_a', 'column_b', 'column_c', 'column_d'],
                    postgresql_concurrently=True
                )
        ```
        
        Good:
        
        ```python
        def upgrade():
            # Limit to most selective columns for better performance
            with op.get_context().autocommit_block():
                op.create_index(
                    'index_users_on_selective_columns',
                    'users',
                    ['column_d', 'column_b'],
                    postgresql_concurrently=True
                )
        ```

Install this rule for Greptile

Greptile rules can be added through the web interface. Please see this documentation for details on how to add custom rules and context.

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```

File Path Patterns:

*.py

Install this rule for GitHub Copilot

Copilot instructions can be added through the interface. See the documentation for details on how to create coding guidelines.

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```

File Path Patterns:

*.py

Install this rule for Graphite Diamond

Diamond custom rules can be added through the interface. See the documentation for details on how to create custom rules.

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```

File Path Patterns:

*.py

Use with Cline

Copy the rule below and ask Cline to review your code using this rule

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```

Use with OpenAI Codex

Copy the rule below and ask OpenAI Codex to review your code using this rule

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```

Use with Cursor

Copy the rule below and ask Cursor to review your code using this rule

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```

Use with Claude Code

Copy the rule below and ask Claude Code to review your code using this rule

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```

Install this rule for Windsurf

To set up rules for Windsurf Reviews, please see this documentation 

Limit non-unique indexes to a maximum of three columns in PostgreSQL databases:
Bad:
```python
def upgrade():
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_multiple_columns',
            'users',
            ['column_a', 'column_b', 'column_c', 'column_d'],
            postgresql_concurrently=True
        )
```
Good:
```python
def upgrade():
    # Limit to most selective columns for better performance
    with op.get_context().autocommit_block():
        op.create_index(
            'index_users_on_selective_columns',
            'users',
            ['column_d', 'column_b'],
            postgresql_concurrently=True
        )
```