Rules Reference

Rules in sqlfluff are implemented as crawlers. These are entities which work their way through the parsed structure of a query to evaluate a particular rule or set of rules. The intent is that the definition of each specific rule should be really streamlined and only contain the logic for the rule itself, with all the other mechanics abstracted away.

Specific Rules

Standard SQL Linting Rules.

class sqlfluff.rules.std.Rule_L001(code, description, **kwargs)

Uneccessary trailing whitespace.

class sqlfluff.rules.std.Rule_L002(tab_space_size=4, **kwargs)

Mixed Tabs and Spaces in single whitespace.

This rule will fail if a single section of whitespace contains both tabs and spaces.

Parameters:tab_space_size (int) – The number of spaces to consider equal to one tab. Used in the fixing step of this rule. Defaults to 4.
class sqlfluff.rules.std.Rule_L003(tab_space_size=4, **kwargs)

Indentation length is not a multiple of {tab_space_size}.

Parameters:tab_space_size (int) – The number of spaces to consider equal to one tab. Used in the fixing step of this rule. Defaults to 4.
class sqlfluff.rules.std.Rule_L004(code, description, **kwargs)

Mixed Tab and Space indentation found in file.

class sqlfluff.rules.std.Rule_L005(code, description, **kwargs)

Commas should not have whitespace directly before them.

class sqlfluff.rules.std.Rule_L006(code, description, **kwargs)

Operators should be surrounded by a single whitespace.

class sqlfluff.rules.std.Rule_L007(code, description, **kwargs)

Operators near newlines should be after, not before the newline.

class sqlfluff.rules.std.Rule_L008(code, description, **kwargs)

Commas should be followed by a single whitespace unless followed by a comment.

class sqlfluff.rules.std.Rule_L009(code, description, **kwargs)

Files must end with a trailing newline.

class sqlfluff.rules.std.Rule_L010(capitalisation_policy='consistent', **kwargs)

Inconsistent capitalisation of keywords.

Parameters:capitalisation_policy (str) – The capitalisation policy to enforce. One of consistent, upper, lower, capitalise.
class sqlfluff.rules.std.Rule_L011(code, description, **kwargs)

Implicit aliasing of table not allowed. Use explicit AS clause.

class sqlfluff.rules.std.Rule_L012(code, description, **kwargs)

Implicit aliasing of column not allowed. Use explicit AS clause.

NB: This rule inherits it’s functionality from obj:Rule_L011 but is seperate so that they can be enabled and disabled seperately.

class sqlfluff.rules.std.Rule_L013(allow_scalar=True, **kwargs)

Column expression without alias. Use explicit AS clause.

Parameters:allow_scalar (bool) – If True then this rule will not fail if there is only one element in the select clause e.g. SELECT 1 + 2 FROM blah. It will still fail if there are multiple columns. (Default True)
class sqlfluff.rules.std.Rule_L014(capitalisation_policy='consistent', **kwargs)

Inconsistent capitalisation of unquoted identifiers.

The functionality for this rule is inherited from Rule_L010.

  • capitalisation_policy (str) – The capitalisation policy to
  • One of 'consistent', 'upper', 'lower', 'capitalise'. (enforce.) –


class sqlfluff.rules.base.RuleSet(name)

Class to define a ruleset.

A rule set is instantiated on module load, but the references to each of it’s classes are instantiated at runtime. This means that configuration values can be passed to those rules live and be responsive to any changes in configuration from the path that the file is in.

Rules should be fetched using the get_rulelist() command which also handles any filtering (i.e. whitelisting and blacklisting).

New rules should be added to the instance of this class using the register() decorator. That decorator registers the class, but also performs basic type and name-convention checks.

The code for the rule will be parsed from the name, the description from the docstring. The eval function is assumed that it will be overriden by the subclass, and the parent class raises an error on this function if not overriden.


Use the config to return the appropriate rules.

We use the config both for whitelisting and blacklisting, but also for configuring the rules given the given config.

Returns:list of instantiated BaseCrawler.

Decorate a class with this to add it to the ruleset.

class Rule_L001(BaseCrawler):
    "Description of rule."

    def eval(self, **kwargs):
        return LintResult()

We expect that rules are defined as classes with the name Rule_XXXX where XXXX is of the form LNNN, where L is a letter (literally L for linting by default) and N is a three digit number.

If this receives classes by any other name, then it will raise a ValueError.

class sqlfluff.rules.base.BaseCrawler(code, description, **kwargs)

The base class for a crawler, of which all rules are derived from.

  • code (str) – The identifier for this rule, used in inclusion or exclusion.
  • description (str) – A human readable description of what this rule does. It will be displayed when any violations are found.

Evaluate this rule against the current context.

This should indicate whether a linting violation has occured and/or whether there is something to remember from this evaluation.

Note that an evaluate function shoul always accept **kwargs, but if it relies on any available kwargs, it should explicitly call them out at definition.

Returns:LintResult or None.

The reason that this method is called _eval() and not eval is a bit of a hack with sphinx autodoc, to make it so that the rule documentation auto-generates nicely.

crawl(segment, parent_stack=None, siblings_pre=None, siblings_post=None, raw_stack=None, fix=False, memory=None)

Recursively perform the crawl operation on a given segment.

Returns:A tuple of (vs, raw_stack, fixes, memory)
class sqlfluff.rules.base.LintResult(anchor=None, fixes=None, memory=None, description=None)

A class to hold the results of a crawl operation.

  • anchor (BaseSegment, optional) – A segment which represents the position of the a problem. NB: Each fix will also hold it’s own reference to position, so this position is mostly for alterting the user to where the problem is.
  • fixes (list of LintFix, optional) – An array of any fixes which would correct this issue. If not present then it’s assumed that this issue will have to manually fixed.
  • memory (dict, optional) – An object which stores any working memory for the crawler. The memory returned in any LintResult will be passed as an input to the next segment to be crawled.
  • description (str, optional) – A description of the problem identified as part of this result. This will override the description of the rule as what gets reported to the user with the problem if provided.

Convert a linting result to a SQLLintError if appropriate.

class sqlfluff.rules.base.LintFix(edit_type, anchor, edit=None)

A class to hold a potential fix to a linting violation.

  • edit_type (str) – One of create, edit, delete to indicate the kind of fix this represents.
  • anchor (BaseSegment) – A segment which represents the position that this fix should be applied at. For deletions it represents the segment to delete, for creations it implies the position to create at (with the existing element at this position to be moved after the edit), for an edit it implies the segment to be replaced.
  • edit (BaseSegment, optional) – For edit and create fixes, this hold the segment, or iterable of segments to create to replace at the given anchor point.

The _eval function of each rule should take enough arguments that it can evaluate the position of the given segment in relation to it’s neighbors, and that the segment which finally “triggers” the error, should be the one that would be corrected OR if the rule relates to something that is missing, then it should flag on the segment FOLLOWING, the place that the desired element is missing.