Count templating or parse errors before and after filtering.

Factory method. When ignoring=templating is configured, use 'name' as the value for undefined variables. We deliberately avoid record

Trim a string nicely to length.

Calculate the desired indent units. This is the heart of the indentation calculations. First we work out how many previous indents a

Dispatch any violations found in a file.

Write the output file content to stdout or file.

Add a block to the stack.

Remove ANSI color codes for testing.

Extract information from a class for documentation. Args: cls: Class object to document module_name: Name of the module containin

Filter the segments to non-meta. Or optionally the opposite if keep_meta is True.

Find corresponding table_aliases entry (if any) matching "table".

Find SQL fixture files for benchmarking. Args: dialect: Specific dialect to test (e.g., 'ansi', 'tsql'). None = all dialects limi

Yields all the positions sbstr within in_str. https://stackoverflow.com/questions/4664850/how-to-find-all-occurrences-of-a-substring

Handle the potential case of an empty point with the next point with segments. While a reflow element's segments are empty, search for the next

Fix SQL files. PATH is the path to a sql file or directory to lint. This can be either a file ('path/to/file.sql'), a path ('directory/of/sql

Format an iterable of config values from a config object.

Output a warning for parsing errors.

Construct a ReflowBlock while extracting relevant configuration. This is the primary route to construct a ReflowBlock, as is allows a

Iterate through the elements to deduce important point indices.

Recursively wrap mappings so nested lookups also fallback.

Generate a DepthMap a sequence of raws and a root. NOTE: This is the less efficient way to construct a DepthMap as it doesn't take ad

Construct template segment from slice of a source file.

Expand a span to a location.

Loads a config object given a series of nested config strings. Args: *config_strings (str): An iterable of config strings, assume

Look for inline ignore comments and return NoQaDirectives.

Get display name for a bundle.

Get the templating context from the config. This function retrieves the templating context from the config by loading the config and

Returns slices touched by the fix.

Recursively search JSON parse result for specified segment type. Args: parse_result (Dict[str, Any]): JSON parse result from `sqlfluff.fi

Fetch the lexer struct for this dialect.

Search for all parsing fixtures.

Testing helper to parse paths.

Iterate raw segments, mostly for searching.

Fetch a rule from the rule set.

Generate a runner instance based on parallel and system configuration. The processes argument can be positive or negative. - If positive, the

Get the configured templater class. .. note:: This is mostly useful to call directly when rules want to determine the *

Is the span surrounded by one (but not two) line breaks? Args: elements: The elements of the ReflowSequence this element

Is either side a templated newline? If either side has a templated newline, then that's ok too. The intent here is that if the next n

Determine whether a point contains any literal newlines. NOTE: We check for standard literal newlines, but also potential placeholder newline

Identify areas in file to rebreak. A span here is a block, or group of blocks which have explicit configs for their line position, either dir

Add a new CTE to the list as late as possible but before all its parents.

Returns a function that determines if it's a matching keyword.

Based on its slice_type, does it only appear in the *source*? There are some slice types which are automatically source only. There a

Work out whether a slice of the source file is a literal or not.

Generate a list of reference strings and elements. Each reference is an ObjectReferencePart. Overrides the base class because hyphens

Return an iterable of tuples representing keys. Args: cfg (optional): An optional config mapping to format instead.

Make a string from the joined `raw` attributes of an iterable of segments.

Basic parsing for the tests below.

Performs a Lex and Parse, with cacheable inputs within fixture.

Lint the indent points to check we have line breaks where we should. For linting indentation - we *first* need to make sure there are line br

Take a RenderedFile and return a LintedFile.

Check CTEs and return used aliases.

Load the given config string and validate. This method is cached to mitigate being called multiple times. This doesn't manage the combinatio

This will never be called. If it is then we're using it wrong.

Given a template location, walk execution to that point. This updates the internal `program_counter` to the appropriate location.

Same as `next_match` but with bracket counting. NB: Given we depend on `next_match` we can also utilise the same performance optimisations wh

Return True if any of the possible references matches a target.

Parses out the contents of the test tag.

Parse an ansi sql string for testing.

Parse an ansi sql string for testing.

Parse example SQL file, return parse tree.

Parse a Google-style docstring into structured sections. Args: docstring: The raw docstring text Returns: Dictionary with ke

Parse parameter list from Google-style docstring. Args: text: Text containing parameter descriptions Returns: List of dicts

Persist the timing records as a csv for external analysis.

Default to test rule if code is omitted.

Process a nested dict or dict-like into a check tuple.

Use the simple matchers to prune which options to match on. Works in the context of a grammar making choices between options such as AnyOf or

Purge the current loaded plugin manager. NOTE: This method should not be used in normal SQFluff operation, but exists so that in the test sui

Return the qualification type of this reference.

Used by JinjaTracer to instantiate templates. This function is a closure capturing internal state from process(). Note that c

Override a segment on the dialect directly. Usage is very similar to add, but elements specified must already exist.

Reset all metrics.

Generates the segment_kwargs package for generating a matched segment.

Given files to be processed, return a valid processing sequence.

Patch a sliced file returned by the superclass.

Is this slice a point.

Return a list a slices which reference the parts only in the source. All of these slices should be expected to have zero-length in th

Create a source position dict from a slice.

Stop the linting timer.

Generate a summary for display.

Convert a template slice to a source slice.

Return a timing summary.

Executes raw_str. Returns template output and trace.

Trim both ends of an intermediate slice.

Take segments and split off surrounding non-code segments as appropriate. We use slices to avoid creating too many unnecessary tuples.

Try to turn this intermediate slice into a simple slice.

Validates the start and end of the sequence based on it's config. Most normal segments may *not* start or end with whitespace. Any su

Get and validate segment for tests below.

Check if the config specifies a dialect, raising an error if not. Raises: SQLFluffUserError: If dialect config value is unset. Th

Returns the combination of violations for this variant. NOTE: This is implemented as a property for backward compatibility.

Calculate visual column position accounting for tab expansion. This calculates the visual column (how it appears on screen) by walking

Return a yaml loading function.

Two grammars are equal if their elements and types are equal. NOTE: We use the equality_kwargs tuple on the class to define other kwa

Constructor for MetaSegment. Args: pos_marker (:obj:`PositionMarker`, optional): The position of the segment.