def _init_global(cls, config, dialect):
"""Initializes any global state.
May be overridden by subclasses to apply global configuration, initialize
logger state in child processes, etc.
"""
Lexer(dialect=dialect)
dialect_selector(dialect)
def test_snowflake_queries(segment_cls, raw, caplog):
"""Test snowflake specific queries parse."""
lnt = Linter(dialect="snowflake")
parsed = lnt.parse_string(raw)
print(parsed.violations)
assert len(parsed.violations) == 0
# Find any unparsable statements
typs = parsed.tree.type_set()
assert "unparsable" not in typs
# Find the expected type in the parsed segment
seg_type = dialect_selector("snowflake").get_segment(segment_cls).type
child_segments = [seg for seg in parsed.tree.recursive_crawl(seg_type)]
assert len(child_segments) > 0
def __init__(
self, configs: Optional[dict] = None, overrides: Optional[dict] = None
):
self._overrides = overrides # We only store this for child configs
defaults = ConfigLoader.get_global().load_default_config_file()
self._configs = nested_combine(
defaults, configs or {"core": {}}, {"core": overrides or {}}
)
# Some configs require special treatment
self._configs["core"]["color"] = (
False if self._configs["core"].get("nocolor", False) else None
)
# Deal with potential ignore parameters
if self._configs["core"].get("ignore", None):
self._configs["core"]["ignore"] = self._configs["core"]["ignore"].split(",")
else:
self._configs["core"]["ignore"] = []
# Whitelists and blacklists
if self._configs["core"].get("rules", None):
self._configs["core"]["rule_whitelist"] = self._configs["core"][
"rules"
].split(",")
else:
self._configs["core"]["rule_whitelist"] = None
if self._configs["core"].get("exclude_rules", None):
self._configs["core"]["rule_blacklist"] = self._configs["core"][
"exclude_rules"
].split(",")
else:
self._configs["core"]["rule_blacklist"] = None
# Configure Recursion
if self._configs["core"].get("recurse", 0) == 0:
self._configs["core"]["recurse"] = True
# Dialect and Template selection.
# NB: We import here to avoid a circular references.
from sqlfluff.core.dialects import dialect_selector
from sqlfluff.core.templaters import templater_selector
self._configs["core"]["dialect_obj"] = dialect_selector(
self._configs["core"]["dialect"]
)
self._configs["core"]["templater_obj"] = templater_selector(
self._configs["core"]["templater"]
)
def test_exasol_queries(segment_cls, raw, stmt_count,
validate_dialect_specific_statements):
"""Test exasol specific queries with parse."""
seg_cls = dialect_selector(TEST_DIALECT).get_segment(segment_cls)
validate_dialect_specific_statements(TEST_DIALECT, seg_cls, raw,
stmt_count)
def __init__(
self,
configs: Optional[dict] = None,
extra_config_path: Optional[str] = None,
ignore_local_config: bool = False,
overrides: Optional[dict] = None,
plugin_manager: Optional[pluggy.PluginManager] = None,
# Ideally a dialect should be set when config is read but sometimes
# it might only be set in nested .sqlfluff config files, so allow it
# to be not required.
require_dialect: bool = True,
):
self._extra_config_path = (
extra_config_path # We only store this for child configs
)
self._ignore_local_config = (
ignore_local_config # We only store this for child configs
)
self._overrides = overrides # We only store this for child configs
# Fetch a fresh plugin manager if we weren't provided with one
self._plugin_manager = plugin_manager or get_plugin_manager()
defaults = nested_combine(*self._plugin_manager.hook.load_default_config())
self._configs = nested_combine(
defaults, configs or {"core": {}}, {"core": overrides or {}}
)
# Some configs require special treatment
self._configs["core"]["color"] = (
False if self._configs["core"].get("nocolor", False) else None
)
# Deal with potential ignore parameters
if self._configs["core"].get("ignore", None):
self._configs["core"]["ignore"] = _split_comma_separated_string(
self._configs["core"]["ignore"]
)
else:
self._configs["core"]["ignore"] = []
# Allowlists and denylists
if self._configs["core"].get("rules", None):
self._configs["core"]["rule_allowlist"] = _split_comma_separated_string(
self._configs["core"]["rules"]
)
else:
self._configs["core"]["rule_allowlist"] = None
if self._configs["core"].get("exclude_rules", None):
self._configs["core"]["rule_denylist"] = _split_comma_separated_string(
self._configs["core"]["exclude_rules"]
)
else:
self._configs["core"]["rule_denylist"] = None
# Configure Recursion
if self._configs["core"].get("recurse", 0) == 0:
self._configs["core"]["recurse"] = True
# Dialect and Template selection.
# NB: We import here to avoid a circular references.
from sqlfluff.core.dialects import dialect_selector
dialect: Optional[str] = self._configs["core"]["dialect"]
if dialect is not None:
self._configs["core"]["dialect_obj"] = dialect_selector(
self._configs["core"]["dialect"]
)
elif require_dialect:
self.verify_dialect_specified()
self._configs["core"]["templater_obj"] = self.get_templater(
self._configs["core"]["templater"]
)
def fresh_ansi_dialect():
"""Expand the ansi dialect for use."""
return dialect_selector("ansi")
def test_exasol_scripts_functions(segment_cls, raw, stmt_count,
validate_dialect_specific_statements):
"""Test exasol specific scripts and functions with parse."""
seg_cls = dialect_selector(TEST_DIALECT).get_segment(segment_cls)
validate_dialect_specific_statements(TEST_DIALECT, seg_cls, raw,
stmt_count)
