Modular SQL Linting for Humans
The SQL Linter for humans
Bored of not having a good SQL linter that works with whichever dialiect you're working with? Fluff is an extensible and modular linter designed to help you write good SQL and catch errors and bad SQL before it hits your database.
Sqlfluff is still in an open alpha phase - expect the tool to change significantly over the coming months, and expect potentially non-backward compatable api changes to happen at any point. If you'd like to help please consider contributing.
- 0.1.x involved a major re-write of the parser, completely changing the behaviour of the tool with respect to complex parsing.
- 0.2.x added templating support and a big restructure of rules and changed how users might interact with sqlfluff on templated code.
- 0.3.x drops support for python 2.7 and 3.4, and also reworks the handling of indentation linting in a potentially not backward compatable way.
To get started just install the package, make a sql file and then run sqlfluff and point it at the file.
$ pip install sqlfluff $ echo " SELECT a + b FROM tbl; " > test.sql $ sqlfluff lint test.sql == [test.sql] FAIL L: 1 | P: 1 | L003 | Single indentation uses a number of spaces not a multiple of 4 L: 1 | P: 14 | L006 | Operators should be surrounded by a single space unless at the start/end of a line L: 1 | P: 27 | L001 | Unnecessary trailing whitespace
For more details on usage see the docs on readthedocs here.
There's lots to do in this project, and we're just getting started. If you want to understand more about the architecture of sqlfluff, you can find more here.
All notable changes to this project will be documented in this file.
[0.3.2] - 2020-05-08
- Support for the Teradata dialect. Thanks @Katzmann1983!
- A much more detailed getting started guide in the docs.
- For the
parsecommand, added the
--benchoptions to help debugging performance issues.
- Support for the
docommand in the jinja templater.
- Proper parsing of the concatenate operator (
- Proper indent handling of closing brackets.
- Logging and benchmarking of parse performance as part of the CI pipeline.
- Parsing of object references with defaults like
- Support for the
INTERVAL '4 days'style interval expression.
- Configurable trailing or leading comma linting.
- Configurable indentation for
- Rules now have their own logging interface to improve debugging ability.
- Snowflake and Postgres dialects.
- Support for a
.sqlfluffignorefile to ignore certain paths.
- More generic interfaces for managing keywords in dialects, including
setinterfaces for managing and creating keywords and the
Ref.keyword()method to refer to them, and the ability to refer directly to keyword names in most grammars using strings directly. Includes
SegmentGeneratorobjects to bind dialect objects at runtime from sets. Thanks @Katzmann1983!
L029for using unreserved keywords as variable names.
- The jinja templater now allows macros loaded from files, and the
hydration of variables ending in
_pathin the config files.
- JSON operators and the
DISTINCT ON ()syntax for the postgres dialect.
- Refactor of whitespace and non-code handling so that segments are less greedy and default to not holding whitespace on ends. This allows more consistent linting rule application.
- Change config file reading to case-sensitive to support case sensitivity in jinja templating.
- Non-string values (including lists) now function in the python and jinja templating libraries.
- Validation of the match results of grammars has been reduced. In production cases the validation will still be done, but only on parse and not on match.
- At low verbosities, python level logging is also reduced.
- Some matcher rules in the parser can now be classified as simple which allows them to shortcut some of the matching routines.
- Yaml output now double quotes values with newlines or tab characters.
- Better handling on hanging and closing indents when linting rule L003.
- More capable handline of multi-line comments so that indentation and line length parsing works. This involves some deep changes to the lexer.
- Getting violations from the linter now automatically takes into account of ignore rules and filters.
- Several bugfixes, including catching potential infinite regress during fixing of files, if one fix would re-introduce a problem with another.
- Behaviour of the
Bracketedgrammar has been changed to treat it's content as a
Sequencerather than a
- Move to
Environmentfor jinja templating for security.
- Improve reporting of templating issues, especially for the jinja templater so that missing variables are rendered as blanks, but still reported as templating violations.
[0.3.1] - 2020-02-17
- Support for
a.b.*on top of
a.*in select target expressions.
[0.3.0] - 2020-02-15
- Deprecated python 2.7 and python 3.4 which are now both past their maintenance horizon. The 0.2.x branch will remain available for continued development for these versions.
- Rule L003 is now significantly smarter in linting indentation with support for hanging indents and comparison to the most recent line which doesn't have an error. The old (more simple) functionality of directly checking whether an indent was a multiple of a preset value has been removed.
- Fixed the "inconsistent" bug in L010. Thanks @nolanbconaway.
- Updated logging of parsing and lexing errors to have more useful error codes.
- Changed parsing of expressions to favour functions over identifiers to fix the expression bug.
- Fixed the "inconsistent" bug in L010. Thanks @nolanbconaway.
- Moved where the
SELECTkeyword is parsed within a select statement, so that it belongs as part of the newly renamed
select_clause(renamed from previously
- Clarified handling of the
nameproperties of the BaseSegment class and it's children.
nameshould be specific to a particular kind of segment, and
typeshould express a wider group. Handling of the
commasegments has been updated so that we use the
typeproperty for most use cases rather than
- Meta segments for indicating where things can be present in the parsed
tree. This is mostly illustrated using the
Dedentsegments used for indicating the position of theoretical indents in the structure. Several helper functions have been added across the codebase to handle this increase in the kinds of segments which might be encountered by various grammars.
- Rule L016 has been added to lint long lines. In the
fixphase of this rule, there is enough logic to try and reconstruct a sensible place for line breaks as re-flow the query. This will likely need further work and may still encounter places where it doesn't fix all errors but should be able to deal with the majority of simple cases.
- BigQuery dialect, initially just for appropriate quoting.
- Added parsing of DDL statements such as
ROLLBACK. Thanks @barrywhart.
--formatoption to the
parsecommand that allows a yaml output. This is mostly to make test writing easier in the development process but might also be useful for other things.
- Parsing of set operations like
- Support for the
diff-covertool. Thanks @barrywhart.
- Enabled the
fixcommand while using
stdin. Thanks @nolanbconaway.
- Rule to detect incorrect use of
DISTINCT. Thanks @barrywhart.
- Security fixes from DeepCover. Thanks @sanketsaurav.
- Automatic fix testing, to help support the newer more complicated rules.
- Interval literals
- Support for the
sourcemacro from dbt. Thanks @Dandandan
- Support for functions with spaces between the function name and the brackets
and a linting rule
L017to catch this.
- Efficiency cache for faster pruning of the parse tree.
- Parsing of array notation as using in BigQuery and Postgres.
- Enable the
ignoreparameter on linting and fixing commands to ignore particular kinds of violations.
[0.2.4] - 2019-12-06
--code-onlyoption to the
parsecommand to spit out a more simplified output with only the code elements.
- Rules can now optionally override the description of the violation
and pass that back via the
- Bugfix, correct missing files in
- Better parsing of the not equal operator.
- Added more exclusions to identifier reserved words to fix cross joins.
- At verbosity levels 2 or above, the root config is printed and then any diffs to that for specific files are also printed.
- Linting and parsing of directories now reports files in alphabetical order. Thanks @barrywhart.
- Better python 2.7 stability. Thanks @barrywhart.
- Fixing parsing of
[0.2.3] - 2019-12-02
- Bugfix, default config not included.
[0.2.2] - 2019-12-02
- Tweek rule L005 to report more sensibly with newlines.
- Rework testing of rules to be more modular.
- Fix a config file bug if no root config file was present for some values. Thanks @barrywhart.
- Lexing rules are now part of the dialect rather than a global so that they can be overriden by other dialects when we get to that stage.
[0.2.0] - 2019-12-01
- Templating support (jinja2, python or raw).
- Variables + Macros.
fixcommand is also sensitive to fixing over templates and will skip certain fixes if it feels that it's conflicted.
- Config file support, including specifying context for the templater.
- Documentation via Sphinx and readthedocs.
- Including a guide on the role of SQL in the real world. Assisted by @barrywhart.
- Documentation LINTING (given we're a linting project) introduced in CI.
- Reimplemented L006 & L007 which lint whitespace around operators.
- Ability to configure rule behaviour direclty from the config file.
- Implemented L010 to lint capitalisation of keywords.
- Allow casting in the parser using the
ORDER BYusing indexes and expressions.
- Added parsing of
- Support for window/aggregate functions.
- Added linting and parsing of alias expressions.
- Fixed a bug which could cause potential infinite recursion in configuration
- Changed how negative literals are handled, so that they're now a compound segment rather than being identified at the lexing stage. This is to allow the parser to resolve the potential ambiguity.
- Restructure of rule definitions to be more streamlined and also enable
autodocumentation. This includes a more complete
RuleSetclass which now holds the filtering code.
- Corrected logging in fix mode not to duplicate the reporting of errors.
- Now allows insert statements with a nested
- Fixed verbose logging during parsing.
- Allow the
Bracketedgrammar to optionally match empty brackets using the optional keyword.
[0.1.5] - 2019-11-11
- Python 3.8 Support!
- Moved some of the responsibility for formatted logging into the linter to mean that we can log progressively in large directories.
- Fixed a bug in the grammar where one of the return values was messed up.
[0.1.4] - 2019-11-10
- Added a
--exclude-rulesargument to most of the commands to allow rule users to exclude specific subset of rules, by @sumitkumar1209
- Added lexing for
- Added a new common segment:
LambdaSegmentwhich allows matching based on arbitrary functions which can be applied to segments.
- Recursive Expressions for both arithmetic and functions, based heavily off the grammar provided by the guys at CockroachDB.
Anythinggrammar, useful in matching rather than in parsing to match anything.
- Complete rewrite of the bracket counting functions, using some centralised class methods
BaseGrammarclass to support common matching features across multiple grammars. In particular this affects the
Delimitedgrammar which is now much simpler but does also require slightly more liberal use of terminators to match effectively.
- Rather than passing around multiple variables during parsing and matching, there is now
ParseContextobject which contains things like the dialect and various depths. This simplifies the parsing and matching code significantly.
- Bracket referencing is now done from the dialect directly, rather than in individual
Grammars (except the
Bracketedgrammar, which still implements it directly). This takes out some originally duplicated code.
- Corrected the parsing of ordering keywords in and
- Removed the
bracket_sensitive_forward_matchmethod from the
BaseGrammar. It was ugly and not flexible enough. It's been replaced by a suite of methods as described above.
[0.1.3] - 2019-10-30
- Tweak to the L001 rule so that it doesn't crash the whole thing.
[0.1.2] - 2019-10-30
- Fixed the errors raised by the lexer.
[0.1.1] - 2019-10-30
- Fixed which modules from sqlfluff are installed in the setup.py. This affects
[0.1.0] - 2019-10-29
- Big Rewrite - some loss in functionality might be apparent compared to pre-0.1.0. Please submit any major problems as issues on github
- Changed unicode handling for better escape codes in python 2. Thanks @mrshu
- BIG rewrite of the parser, completely new architecture. This introduces
breaking changes and some loss of functionality while we catch up.
- In particular, matches now return partial matches to speed up parsing.
Delimitedmatcher has had a significant re-write with a major speedup and broken the dependency on
- Rewrite of
Sequenceto use partial matches properly.
- Different treatment of numeric literals.
Delimitedrespect bracket counting.
- MASSIVE rewrite of
- Grammars now have timers.
- Joins properly parsing,
- Rewrite of logging to selectively output commands at different levels
of verbosity. This uses the
- Added a command line
sqlfluff parseoption which runs just the parsing step of the process to better understand how a file is being parsed. This also has options to configure how deep we recurse.
- Complete Re-write of the rules section, implementing new
crawlerswhich implement the linting rules. Now with inbuilt fixers in them.
- Old rules removed and re implemented so we now have parity with the old rule sets.
- Moved to using Ref mostly within the core grammar so that we can have recursion.
- Used recursion to do a first implementation of arithmetic parsing. Including a test for it.
- Moved the main grammar into a seperate dialect and renamed source and test files accordingly.
- Moved to file-based tests for the ansi dialect to make it easier to test using the tool directly.
- As part of file tests - expected outcomes are now encoded in yaml to make it easier to write new tests.
- Vastly improved readability and debugging potential of the _match logging.
- Added support for windows line endings in the lexer.
[0.0.7] - 2018-11-19
- Added a
sqlfluff fixas a command to implement auto-fixing of linting errors. For now only
L001is implemented as a rule that can fix things.
- Added a
rulescommand to introspect the available rules.
- Updated the cli table function to use the
testwraplibrary and also deal a lot better with longer values.
- Added a
--rulesargument to most of the commands to allow rule users to focus their search on a specific subset of rules.
- Refactor the cli tests to use the click CliRunner. Much faster
[0.0.6] - 2018-11-15
- Number matching
- Fixed operator parsing and linting (including allowing the exception of
[0.0.5] - 2018-11-15
- Much better documentation including the DOCS.md
- Fixed comma parsing and linting
[0.0.4] - 2018-11-14
- Added operator regexes
- Added a priority for matchers to resolve some ambiguity
- Added tests for operator regexes
- Added ability to initialise the memory in rules
[0.0.3] - 2018-11-14
- Refactor of rules to allow rules with memory
- Adding comma linting rules (correcting the single character matchers)
- Adding mixed indentation linting rules
- Integration with CircleCI, CodeCov and lots of badges
- Changed import of version information to fix bug with importing config.ini
- Added basic violations/file reporting for some verbosities
- Refactor of rules to simplify definition
- Refactor of color cli output to make it more reusable
[0.0.2] - 2018-11-09
- Longer project description
- Proper exit codes
- colorama for colored output
- Significant CLI changes
- Much improved output from CLI
[0.0.1] - 2018-11-07
- Initial Commit! - VERY ALPHA
- Restructure into package layout
- Adding Tox and Pytest so that they work
Release history Release notifications | RSS feed
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.