SYMBOL INDEX (341 symbols across 27 files)

FILE: SQLTools.py
  function getSublimeUserFolder (line 53) | def getSublimeUserFolder():
  function startPlugin (line 57) | def startPlugin():
  function readConnections (line 103) | def readConnections():
  function getDefaultConnectionName (line 127) | def getDefaultConnectionName():
  function createOutput (line 134) | def createOutput(panel=None, syntax=None, prependText=None):
  function toNewTab (line 158) | def toNewTab(content, name="", suffix="SQLTools Saved Query"):
  function insertContent (line 166) | def insertContent(content):
  function getOutputPlace (line 180) | def getOutputPlace(syntax=None, name="SQLTools Result"):
  function getSelectionText (line 232) | def getSelectionText():
  function getSelectionRegions (line 246) | def getSelectionRegions():
  function getCurrentSyntax (line 290) | def getCurrentSyntax():
  class ST (line 298) | class ST(EventListener):
    method bootstrap (line 307) | def bootstrap():
    method setDefaultConnection (line 312) | def setDefaultConnection():
    method setConnection (line 323) | def setConnection(connectionName, callback=None):
    method loadConnectionData (line 385) | def loadConnectionData(callback=None):
    method selectConnectionQuickPanel (line 432) | def selectConnectionQuickPanel(callback=None):
    method showTablesQuickPanel (line 471) | def showTablesQuickPanel(callback):
    method showFunctionsQuickPanel (line 479) | def showFunctionsQuickPanel(callback):
    method showQuickPanelWithSelection (line 487) | def showQuickPanelWithSelection(arrayOfValues, callback):
    method on_query_completions (line 506) | def on_query_completions(view, prefix, locations):
  class StShowConnectionMenu (line 580) | class StShowConnectionMenu(WindowCommand):
    method run (line 582) | def run():
  class StSelectConnection (line 586) | class StSelectConnection(WindowCommand):
    method run (line 588) | def run():
  class StShowRecords (line 592) | class StShowRecords(WindowCommand):
    method run (line 594) | def run():
  class StDescTable (line 612) | class StDescTable(WindowCommand):
    method run (line 614) | def run():
  class StDescFunction (line 630) | class StDescFunction(WindowCommand):
    method run (line 632) | def run():
  class StRefreshConnectionData (line 651) | class StRefreshConnectionData(WindowCommand):
    method run (line 653) | def run():
  class StExplainPlan (line 659) | class StExplainPlan(WindowCommand):
    method run (line 661) | def run():
  class StExecute (line 670) | class StExecute(WindowCommand):
    method run (line 672) | def run():
  class StExecuteAll (line 681) | class StExecuteAll(WindowCommand):
    method run (line 683) | def run():
  class StFormat (line 693) | class StFormat(TextCommand):
    method run (line 695) | def run(edit):
  class StFormatAll (line 706) | class StFormatAll(TextCommand):
    method run (line 708) | def run(edit):
  class StVersion (line 714) | class StVersion(WindowCommand):
    method run (line 716) | def run():
  class StHistory (line 720) | class StHistory(WindowCommand):
    method run (line 722) | def run():
  class StSaveQuery (line 739) | class StSaveQuery(WindowCommand):
    method run (line 741) | def run():
  class StListQueries (line 749) | class StListQueries(WindowCommand):
    method run (line 751) | def run(mode="run"):
  class StRemoveSavedQuery (line 787) | class StRemoveSavedQuery(WindowCommand):
    method run (line 789) | def run():
  function Window (line 815) | def Window():
  function View (line 819) | def View():
  function reload (line 823) | def reload():
  function plugin_loaded (line 843) | def plugin_loaded():
  function plugin_unloaded (line 865) | def plugin_unloaded():

FILE: SQLToolsAPI/Command.py
  class Command (line 11) | class Command(object):
    method __init__ (line 14) | def __init__(self, args, env, callback, query=None, encoding='utf-8',
    method run (line 36) | def run(self):
    method _formatShowQuery (line 121) | def _formatShowQuery(query, queryTimeStart, queryTimeEnd):
    method createAndRun (line 131) | def createAndRun(args, env, callback, query=None, encoding='utf-8',
  class ThreadCommand (line 147) | class ThreadCommand(Command, Thread):
    method __init__ (line 148) | def __init__(self, args, env, callback, query=None, encoding='utf-8',
    method stop (line 165) | def stop(self):
    method createAndRun (line 191) | def createAndRun(args, env, callback, query=None, encoding='utf-8',

FILE: SQLToolsAPI/Completion.py
  function _stripQuotes (line 22) | def _stripQuotes(ident):
  function _stripQuotesOnDemand (line 27) | def _stripQuotesOnDemand(ident, doStrip=True):
  function _startsWithQuote (line 33) | def _startsWithQuote(ident):
  function _stripPrefix (line 39) | def _stripPrefix(text, prefix):
  function _escapeDollarSign (line 46) | def _escapeDollarSign(ident):
  class CompletionItem (line 50) | class CompletionItem(namedtuple('CompletionItem', ['type', 'ident'])):
    method parent (line 58) | def parent(self):
    method name (line 66) | def name(self):
    method _matchIdent (line 72) | def _matchIdent(self):
    method _stringMatched (line 84) | def _stringMatched(target, search, exactly):
    method prefixMatchScore (line 100) | def prefixMatchScore(self, search, exactly=False):
    method prefixMatchListScore (line 132) | def prefixMatchListScore(self, searchList, exactly=False):
    method format (line 140) | def format(self, stripQuotes=False):
  class Completion (line 165) | class Completion:
    method __init__ (line 166) | def __init__(self, allTables, allColumns, allFunctions, settings=None):
    method getActiveSelectors (line 210) | def getActiveSelectors(self):
    method getIgnoreSelectors (line 213) | def getIgnoreSelectors(self):
    method isDisabled (line 216) | def isDisabled(self):
    method getAutoCompleteList (line 219) | def getAutoCompleteList(self, prefix, sql, sqlToCursor):
    method _getAutoCompleteListBasic (line 240) | def _getAutoCompleteListBasic(self, prefix):
    method _getAutoCompleteListSmart (line 265) | def _getAutoCompleteListSmart(self, prefix, sql, sqlToCursor):
    method _noDotsCompletions (line 327) | def _noDotsCompletions(self, prefix, identifiers, joinAlias=None):
    method _singleDotCompletions (line 427) | def _singleDotCompletions(self, prefix, identifiers, joinAlias=None):
    method _multiDotCompletions (line 500) | def _multiDotCompletions(self, prefix, identifiers):
    method _joinConditionCompletions (line 512) | def _joinConditionCompletions(self, identifiers, joinAlias=None):

FILE: SQLToolsAPI/Connection.py
  function _encoding_exists (line 13) | def _encoding_exists(enc):
  class Connection (line 21) | class Connection(object):
    method __init__ (line 48) | def __init__(self, name, options, settings=None, commandClass='ThreadC...
    method __str__ (line 80) | def __str__(self):
    method info (line 83) | def info(self):
    method runInternalNamedQueryCommand (line 87) | def runInternalNamedQueryCommand(self, queryName, callback):
    method getTables (line 110) | def getTables(self, callback):
    method getColumns (line 113) | def getColumns(self, callback):
    method getFunctions (line 116) | def getFunctions(self, callback):
    method runFormattedNamedQueryCommand (line 119) | def runFormattedNamedQueryCommand(self, queryName, formatValues, callb...
    method getTableRecords (line 145) | def getTableRecords(self, tableName, callback):
    method getTableDescription (line 150) | def getTableDescription(self, tableName, callback):
    method getFunctionDescription (line 153) | def getFunctionDescription(self, functionName, callback):
    method explainPlan (line 156) | def explainPlan(self, queries, callback):
    method execute (line 179) | def execute(self, queries, callback, stream=None):
    method getNamedQuery (line 227) | def getNamedQuery(self, queryName):
    method buildNamedQuery (line 234) | def buildNamedQuery(self, queryName, queries):
    method buildArgs (line 268) | def buildArgs(self, queryName=None):
    method buildEnv (line 308) | def buildEnv(self):
    method getOptionsForSgdbCli (line 333) | def getOptionsForSgdbCli(self):
    method formatOptionalArgument (line 337) | def formatOptionalArgument(argument, formatOptions):
    method setTimeout (line 348) | def setTimeout(timeout):
    method setHistoryManager (line 353) | def setHistoryManager(manager):

FILE: SQLToolsAPI/History.py
  class SizeException (line 4) | class SizeException(Exception):
  class NotFoundException (line 8) | class NotFoundException(Exception):
  class History (line 12) | class History:
    method __init__ (line 14) | def __init__(self, maxSize=100):
    method add (line 18) | def add(self, query):
    method get (line 23) | def get(self, index):
    method setMaxSize (line 29) | def setMaxSize(self, size=100):
    method getMaxSize (line 36) | def getMaxSize(self):
    method getSize (line 39) | def getSize(self):
    method all (line 42) | def all(self):
    method clear (line 45) | def clear(self):

FILE: SQLToolsAPI/ParseUtils.py
  class Reference (line 16) | class Reference(namedtuple('Reference', ['schema', 'name', 'alias', 'is_...
    method has_alias (line 19) | def has_alias(self):
    method is_query_alias (line 23) | def is_query_alias(self):
    method is_table_alias (line 27) | def is_table_alias(self):
    method full_name (line 31) | def full_name(self):
  function _is_subselect (line 38) | def _is_subselect(parsed):
  function _identifier_is_function (line 48) | def _identifier_is_function(identifier):
  function _extract_from_part (line 52) | def _extract_from_part(parsed):
  function _extract_table_identifiers (line 91) | def _extract_table_identifiers(token_stream):
  function extractTables (line 112) | def extractTables(sql):

FILE: SQLToolsAPI/Storage.py
  class Storage (line 8) | class Storage:
    method __init__ (line 9) | def __init__(self, filename, default=None):
    method all (line 20) | def all(self):
    method write (line 30) | def write(self):
    method add (line 33) | def add(self, key, value):
    method delete (line 45) | def delete(self, key):
    method get (line 53) | def get(self, key, default=None):
    method getFilename (line 60) | def getFilename(self):
    method defaults (line 63) | def defaults(self):
  class Settings (line 69) | class Settings(Storage):

FILE: SQLToolsAPI/Utils.py
  function parseJson (line 21) | def parseJson(filename):
  function saveJson (line 50) | def saveJson(content, filename):
  function getResultAsList (line 56) | def getResultAsList(results):
  function formatSql (line 67) | def formatSql(raw, settings):
  function merge (line 76) | def merge(source, destination):

FILE: SQLToolsAPI/lib/sqlparse/__init__.py
  function parse (line 24) | def parse(sql, encoding=None):
  function parsestream (line 34) | def parsestream(stream, encoding=None):
  function format (line 46) | def format(sql, encoding=None, **options):
  function split (line 63) | def split(sql, encoding=None):

FILE: SQLToolsAPI/lib/sqlparse/cli.py
  function create_parser (line 34) | def create_parser():
  function _error (line 139) | def _error(msg):
  function main (line 145) | def main(args=None):

FILE: SQLToolsAPI/lib/sqlparse/compat.py
  function unicode_compatible (line 26) | def unicode_compatible(cls):
  function unicode_compatible (line 37) | def unicode_compatible(cls):

FILE: SQLToolsAPI/lib/sqlparse/engine/filter_stack.py
  class FilterStack (line 15) | class FilterStack(object):
    method __init__ (line 16) | def __init__(self):
    method enable_grouping (line 22) | def enable_grouping(self):
    method run (line 25) | def run(self, sql, encoding=None):

FILE: SQLToolsAPI/lib/sqlparse/engine/grouping.py
  function _group_matching (line 17) | def _group_matching(tlist, cls):
  function group_brackets (line 52) | def group_brackets(tlist):
  function group_parenthesis (line 56) | def group_parenthesis(tlist):
  function group_case (line 60) | def group_case(tlist):
  function group_if (line 64) | def group_if(tlist):
  function group_for (line 68) | def group_for(tlist):
  function group_begin (line 72) | def group_begin(tlist):
  function group_typecasts (line 76) | def group_typecasts(tlist):
  function group_period (line 90) | def group_period(tlist):
  function group_as (line 115) | def group_as(tlist):
  function group_assignment (line 132) | def group_assignment(tlist):
  function group_comparison (line 149) | def group_comparison(tlist):
  function group_identifier (line 174) | def group_identifier(tlist):
  function group_arrays (line 183) | def group_arrays(tlist):
  function group_operator (line 203) | def group_operator(tlist):
  function group_identifier_list (line 223) | def group_identifier_list(tlist):
  function group_comments (line 245) | def group_comments(tlist):
  function group_where (line 258) | def group_where(tlist):
  function group_aliased (line 275) | def group_aliased(tlist):
  function group_functions (line 288) | def group_functions(tlist):
  function group_order (line 307) | def group_order(tlist):
  function align_comments (line 319) | def align_comments(tlist):
  function group (line 329) | def group(stmt):
  function _group (line 361) | def _group(tlist, cls, match,

FILE: SQLToolsAPI/lib/sqlparse/engine/statement_splitter.py
  class StatementSplitter (line 11) | class StatementSplitter(object):
    method __init__ (line 14) | def __init__(self):
    method _reset (line 17) | def _reset(self):
    method _change_splitlevel (line 27) | def _change_splitlevel(self, ttype, value):
    method process (line 77) | def process(self, stream):

FILE: SQLToolsAPI/lib/sqlparse/exceptions.py
  class SQLParseError (line 11) | class SQLParseError(Exception):

FILE: SQLToolsAPI/lib/sqlparse/filters/aligned_indent.py
  class AlignedIndentFilter (line 13) | class AlignedIndentFilter(object):
    method __init__ (line 24) | def __init__(self, char=' ', n='\n'):
    method nl (line 31) | def nl(self, offset=1):
    method _process_statement (line 40) | def _process_statement(self, tlist):
    method _process_parenthesis (line 47) | def _process_parenthesis(self, tlist):
    method _process_identifierlist (line 59) | def _process_identifierlist(self, tlist):
    method _process_case (line 66) | def _process_case(self, tlist):
    method _next_token (line 89) | def _next_token(self, tlist, idx=-1):
    method _split_kwds (line 99) | def _split_kwds(self, tlist):
    method _process_default (line 111) | def _process_default(self, tlist):
    method _process (line 122) | def _process(self, tlist):
    method process (line 127) | def process(self, stmt):

FILE: SQLToolsAPI/lib/sqlparse/filters/others.py
  class StripCommentsFilter (line 12) | class StripCommentsFilter(object):
    method _process (line 14) | def _process(tlist):
    method process (line 34) | def process(self, stmt):
  class StripWhitespaceFilter (line 40) | class StripWhitespaceFilter(object):
    method _stripws (line 41) | def _stripws(self, tlist):
    method _stripws_default (line 47) | def _stripws_default(tlist):
    method _stripws_identifierlist (line 56) | def _stripws_identifierlist(self, tlist):
    method _stripws_parenthesis (line 70) | def _stripws_parenthesis(self, tlist):
    method process (line 77) | def process(self, stmt, depth=0):
  class SpacesAroundOperatorsFilter (line 85) | class SpacesAroundOperatorsFilter(object):
    method _process (line 87) | def _process(tlist):
    method process (line 104) | def process(self, stmt):
  class SerializerUnicode (line 113) | class SerializerUnicode(object):
    method process (line 115) | def process(stmt):

FILE: SQLToolsAPI/lib/sqlparse/filters/output.py
  class OutputFilter (line 12) | class OutputFilter(object):
    method __init__ (line 15) | def __init__(self, varname='sql'):
    method _process (line 19) | def _process(self, stream, varname, has_nl):
    method process (line 22) | def process(self, stmt):
  class OutputPythonFilter (line 34) | class OutputPythonFilter(OutputFilter):
    method _process (line 35) | def _process(self, stream, varname, has_nl):
  class OutputPHPFilter (line 78) | class OutputPHPFilter(OutputFilter):
    method _process (line 81) | def _process(self, stream, varname, has_nl):

FILE: SQLToolsAPI/lib/sqlparse/filters/reindent.py
  class ReindentFilter (line 13) | class ReindentFilter(object):
    method __init__ (line 14) | def __init__(self, width=2, char=' ', wrap_after=0, n='\n',
    method _flatten_up_to_token (line 26) | def _flatten_up_to_token(self, token):
    method leading_ws (line 37) | def leading_ws(self):
    method _get_offset (line 40) | def _get_offset(self, token):
    method nl (line 46) | def nl(self, offset=0):
    method _next_token (line 51) | def _next_token(self, tlist, idx=-1):
    method _split_kwds (line 66) | def _split_kwds(self, tlist):
    method _split_statements (line 82) | def _split_statements(self, tlist):
    method _process (line 96) | def _process(self, tlist):
    method _process_where (line 101) | def _process_where(self, tlist):
    method _process_parenthesis (line 109) | def _process_parenthesis(self, tlist):
    method _process_identifierlist (line 119) | def _process_identifierlist(self, tlist):
    method _process_case (line 149) | def _process_case(self, tlist):
    method _process_default (line 168) | def _process_default(self, tlist, stmts=True):
    method process (line 174) | def process(self, stmt):

FILE: SQLToolsAPI/lib/sqlparse/filters/right_margin.py
  class RightMarginFilter (line 15) | class RightMarginFilter(object):
    method __init__ (line 20) | def __init__(self, width=79):
    method _process (line 24) | def _process(self, group, stream):
    method process (line 46) | def process(self, group):

FILE: SQLToolsAPI/lib/sqlparse/filters/tokens.py
  class _CaseFilter (line 12) | class _CaseFilter(object):
    method __init__ (line 15) | def __init__(self, case=None):
    method process (line 19) | def process(self, stream):
  class KeywordCaseFilter (line 26) | class KeywordCaseFilter(_CaseFilter):
  class IdentifierCaseFilter (line 30) | class IdentifierCaseFilter(_CaseFilter):
    method process (line 33) | def process(self, stream):
  class TruncateStringFilter (line 40) | class TruncateStringFilter(object):
    method __init__ (line 41) | def __init__(self, width, char):
    method process (line 45) | def process(self, stream):

FILE: SQLToolsAPI/lib/sqlparse/formatter.py
  function validate_options (line 14) | def validate_options(options):
  function build_filter_stack (line 118) | def build_filter_stack(stack, options):

FILE: SQLToolsAPI/lib/sqlparse/keywords.py
  function is_keyword (line 13) | def is_keyword(value):

FILE: SQLToolsAPI/lib/sqlparse/lexer.py
  class Lexer (line 21) | class Lexer(object):
    method get_tokens (line 27) | def get_tokens(text, encoding=None):
  function tokenize (line 75) | def tokenize(sql, encoding=None):

FILE: SQLToolsAPI/lib/sqlparse/sql.py
  class Token (line 19) | class Token(object):
    method __init__ (line 30) | def __init__(self, ttype, value):
    method __str__ (line 40) | def __str__(self):
    method __repr__ (line 47) | def __repr__(self):
    method _get_repr_name (line 55) | def _get_repr_name(self):
    method _get_repr_value (line 58) | def _get_repr_value(self):
    method flatten (line 64) | def flatten(self):
    method match (line 68) | def match(self, ttype, values, regex=False):
    method within (line 102) | def within(self, group_cls):
    method is_child_of (line 115) | def is_child_of(self, other):
    method has_ancestor (line 119) | def has_ancestor(self, other):
  class TokenList (line 130) | class TokenList(Token):
    method __init__ (line 139) | def __init__(self, tokens=None):
    method __str__ (line 145) | def __str__(self):
    method __iter__ (line 152) | def __iter__(self):
    method __getitem__ (line 155) | def __getitem__(self, item):
    method _get_repr_name (line 158) | def _get_repr_name(self):
    method _pprint_tree (line 161) | def _pprint_tree(self, max_depth=None, depth=0, f=None):
    method get_token_at_offset (line 175) | def get_token_at_offset(self, offset):
    method flatten (line 184) | def flatten(self):
    method get_sublists (line 196) | def get_sublists(self):
    method _groupable_tokens (line 202) | def _groupable_tokens(self):
    method _token_matching (line 205) | def _token_matching(self, funcs, start=0, end=None, reverse=False):
    method token_first (line 227) | def token_first(self, skip_ws=True, skip_cm=False):
    method token_next_by (line 241) | def token_next_by(self, i=None, m=None, t=None, idx=-1, end=None):
    method token_not_matching (line 246) | def token_not_matching(self, funcs, idx):
    method token_matching (line 251) | def token_matching(self, funcs, idx):
    method token_prev (line 254) | def token_prev(self, idx, skip_ws=True, skip_cm=False):
    method token_next (line 264) | def token_next(self, idx, skip_ws=True, skip_cm=False, _reverse=False):
    method token_index (line 278) | def token_index(self, token, start=0):
    method group_tokens (line 283) | def group_tokens(self, grp_cls, start, end, include_end=True,
    method insert_before (line 313) | def insert_before(self, where, token):
    method insert_after (line 320) | def insert_after(self, where, token, skip_ws=True):
    method has_alias (line 331) | def has_alias(self):
    method get_alias (line 335) | def get_alias(self):
    method get_name (line 348) | def get_name(self):
    method get_real_name (line 357) | def get_real_name(self):
    method get_parent_name (line 363) | def get_parent_name(self):
    method _get_first_name (line 372) | def _get_first_name(self, idx=None, reverse=False, keywords=False):
  class Statement (line 389) | class Statement(TokenList):
    method get_type (line 392) | def get_type(self):
  class Identifier (line 427) | class Identifier(TokenList):
    method is_wildcard (line 433) | def is_wildcard(self):
    method get_typecast (line 438) | def get_typecast(self):
    method get_ordering (line 444) | def get_ordering(self):
    method get_array_indices (line 449) | def get_array_indices(self):
  class IdentifierList (line 458) | class IdentifierList(TokenList):
    method get_identifiers (line 461) | def get_identifiers(self):
  class Parenthesis (line 471) | class Parenthesis(TokenList):
    method _groupable_tokens (line 477) | def _groupable_tokens(self):
  class SquareBrackets (line 481) | class SquareBrackets(TokenList):
    method _groupable_tokens (line 487) | def _groupable_tokens(self):
  class Assignment (line 491) | class Assignment(TokenList):
  class If (line 495) | class If(TokenList):
  class For (line 501) | class For(TokenList):
  class Comparison (line 507) | class Comparison(TokenList):
    method left (line 511) | def left(self):
    method right (line 515) | def right(self):
  class Comment (line 519) | class Comment(TokenList):
    method is_multiline (line 522) | def is_multiline(self):
  class Where (line 526) | class Where(TokenList):
  class Case (line 533) | class Case(TokenList):
    method get_cases (line 538) | def get_cases(self, skip_ws=False):
  class Function (line 586) | class Function(TokenList):
    method get_parameters (line 589) | def get_parameters(self):
  class Begin (line 600) | class Begin(TokenList):
  class Operation (line 606) | class Operation(TokenList):

FILE: SQLToolsAPI/lib/sqlparse/tokens.py
  class _TokenType (line 15) | class _TokenType(tuple):
    method __contains__ (line 18) | def __contains__(self, item):
    method __getattr__ (line 21) | def __getattr__(self, name):
    method __repr__ (line 27) | def __repr__(self):

FILE: SQLToolsAPI/lib/sqlparse/utils.py
  function split_unquoted_newlines (line 37) | def split_unquoted_newlines(stmt):
  function remove_quotes (line 55) | def remove_quotes(val):
  function recurse (line 64) | def recurse(*cls):
  function imt (line 82) | def imt(token, i=None, m=None, t=None):
  function consume (line 106) | def consume(iterator, n):
  function offset (line 112) | def offset(filter_, n=0):
  function indent (line 119) | def indent(filter_, n=1):