Seg Out 3 02:56:14 BRT 2016

Author: mtxr

SQLToolsAPI

@@ -0,0 +1,6 @@
+[bumpversion]
+current_version = 0.0.2
+files = __init__.py README.md
+commit = True
+tag = True
+

SQLToolsAPI/.bumpversion.cfg

@@ -0,0 +1,85 @@
+import os
+import signal
+import subprocess
+
+from threading import Thread, Timer
+from .Log import Log
+
+
+class Command:
+    timeout = 5000
+
+    def __init__(self, args, callback, query=None, encoding='utf-8'):
+        self.query = query
+        self.process = None
+        self.args = args
+        self.encoding = encoding
+        self.callback = callback
+        Thread.__init__(self)
+
+    def run(self):
+        if not self.query:
+            return
+
+        self.args = map(str, self.args)
+        si = None
+        if os.name == 'nt':
+            si = subprocess.STARTUPINFO()
+            si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+
+        self.process = subprocess.Popen(self.args,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.PIPE,
+                                        stdin=subprocess.PIPE,
+                                        env=os.environ.copy(),
+                                        startupinfo=si)
+
+        results, errors = self.process.communicate(input=self.query.encode())
+
+        resultString = ''
+
+        if results:
+            resultString += results.decode(self.encoding,
+                                           'replace').replace('\r', '')
+
+        if errors:
+            resultString += errors.decode(self.encoding,
+                                          'replace').replace('\r', '')
+
+        self.callback(resultString)
+
+    @staticmethod
+    def createAndRun(args, query, callback):
+        command = Command(args, callback, query)
+        command.run()
+
+
+class ThreadCommand(Command, Thread):
+    def __init__(self, args, callback, query=None, encoding='utf-8',
+                 timeout=Command.timeout):
+        self.query = query
+        self.process = None
+        self.args = args
+        self.encoding = encoding
+        self.callback = callback
+        self.timeout = timeout
+        Thread.__init__(self)
+
+    def stop(self):
+        if not self.process:
+            return
+
+        try:
+            os.kill(self.process.pid, signal.SIGKILL)
+            self.process = None
+
+            Log.debug("Your command is taking too long to run. Process killed")
+        except Exception:
+            pass
+
+    @staticmethod
+    def createAndRun(args, query, callback):
+        command = ThreadCommand(args, callback, query)
+        command.start()
+        killTimeout = Timer(command.timeout, command.stop)
+        killTimeout.start()

SQLToolsAPI/Command.py

@@ -0,0 +1,148 @@
+import shutil
+import shlex
+
+from .Log import Log
+from . import Utils as U
+from .Command import ThreadCommand as Command
+
+
+class Connection:
+    history=None
+
+    def __init__(self, name, options, settings={}):
+
+        self.cli = settings.get('cli')[options['type']]
+        cli_path = shutil.which(self.cli)
+
+        if cli_path is None:
+            Log((
+                "'{0}' could not be found by Sublime Text.\n\n" +
+                "Please set the '{0}' path in your SQLTools settings " +
+                "before continue.").format(self.cli))
+            return
+
+        self.settings = settings
+        self.rowsLimit = settings.get('show_records', {}).get('limit', 50)
+        self.options = options
+        self.name = name
+        self.type = options['type']
+        self.host = options['host']
+        self.port = options['port']
+        self.username = options['username']
+        self.database = options['database']
+
+        if 'encoding' in options:
+            self.encoding = options['encoding']
+
+        if 'password' in options:
+            self.password = options['password']
+
+        if 'service' in options:
+            self.service = options['service']
+
+    def __str__(self):
+        return self.name
+
+    def _info(self):
+        return 'DB: {0}, Connection: {1}@{2}:{3}'.format(
+            self.database, self.username, self.host, self.port)
+
+    def getTables(self, callback):
+        query = self.getOptionsForSgdbCli()['queries']['desc']['query']
+
+        def cb(result):
+            callback(U.getResultAsList(result))
+
+        Command.createAndRun(self.builArgs('desc'), query, cb)
+
+    def getColumns(self, callback):
+
+        def cb(result):
+            callback(U.getResultAsList(result))
+
+        try:
+            query = self.getOptionsForSgdbCli()['queries']['columns']['query']
+            Command.createAndRun(self.builArgs('columns'), query, cb)
+        except Exception:
+            pass
+
+    def getFunctions(self, callback):
+
+        def cb(result):
+            callback(U.getResultAsList(result))
+
+        try:
+            query = self.getOptionsForSgdbCli()['queries'][
+                'functions']['query']
+            Command.createAndRun(self.builArgs(
+                'functions'), query, cb)
+        except Exception:
+            pass
+
+    def getTableRecords(self, tableName, callback):
+        query = self.getOptionsForSgdbCli()['queries']['show records'][
+            'query'].format(tableName, self.rowsLimit)
+        Command.createAndRun(self.builArgs('show records'), query, callback)
+
+    def getTableDescription(self, tableName, callback):
+        query = self.getOptionsForSgdbCli()['queries']['desc table'][
+            'query'] % tableName
+        Command.createAndRun(self.builArgs('desc table'), query, callback)
+
+    def getFunctionDescription(self, functionName, callback):
+        query = self.getOptionsForSgdbCli()['queries']['desc function'][
+            'query'] % functionName
+        Command.createAndRun(self.builArgs('desc function'), query, callback)
+
+    def execute(self, queries, callback):
+        queryToRun = ''
+
+        for query in self.getOptionsForSgdbCli()['before']:
+            queryToRun += query + "\n"
+
+        if isinstance(queries, str):
+            queries = [queries]
+
+        for query in queries:
+            queryToRun += query + "\n"
+
+        queryToRun = queryToRun.rstrip('\n')
+
+        Log("Query: " + queryToRun)
+
+        if Connection.history:
+            Connection.history.add(queryToRun)
+
+        Command.createAndRun(self.builArgs(), queryToRun, callback)
+
+    def builArgs(self, queryName=None):
+        cliOptions = self.getOptionsForSgdbCli()
+        args = [self.cli]
+
+        if len(cliOptions['options']) > 0:
+            args = args + cliOptions['options']
+
+        if queryName and len(cliOptions['queries'][queryName]['options']) > 0:
+            args = args + cliOptions['queries'][queryName]['options']
+
+        if isinstance(cliOptions['args'], list):
+            cliOptions['args'] = ' '.join(cliOptions['args'])
+
+        cliOptions = cliOptions['args'].format(**self.options)
+        args = args + shlex.split(cliOptions)
+
+        # Log('Using cli args ' + ' '.join(args))
+        return args
+
+    def getOptionsForSgdbCli(self):
+        return self.settings.get('cli_options', {}).get(self.type)
+
+    @staticmethod
+    def setTimeout(timeout):
+        Connection.timeout = timeout
+        Log('Connection timeout setted to {0} seconds'.format(timeout))
+
+    @staticmethod
+    def setHistoryManager(manager):
+        Connection.history = manager
+        Log('Connection history defined with max size {0}'.format(manager.getMaxSize()))

SQLToolsAPI/Connection.py

@@ -0,0 +1,47 @@
+__version__ = "v0.1.0"
+
+
+class SizeException(Exception):
+    pass
+
+
+class NotFoundException(Exception):
+    pass
+
+
+class History:
+
+    def __init__(self, maxSize=100):
+        self.items = []
+        self.maxSize = maxSize
+
+    def add(self, query):
+        if self.getSize() >= self.getMaxSize():
+            self.items.pop(0)
+        self.items.insert(0, query)
+
+    def get(self, index):
+        if index < 0 or index > (len(self.items) - 1):
+            raise NotFoundException("No query selected")
+
+        return self.items[index]
+
+    def setMaxSize(self, size=100):
+        if size < 1:
+            raise SizeException("Size can't be lower than 1")
+
+        self.maxSize = size
+        return self.maxSize
+
+    def getMaxSize(self):
+        return self.maxSize
+
+    def getSize(self):
+        return len(self.items)
+
+    def all(self):
+        return self.items
+
+    def clear(self):
+        self.items = []
+        return self.items

SQLToolsAPI/History.py

@@ -0,0 +1,45 @@
+VERSION = "v0.1.0"
+
+
+class Logger:
+    logging = False
+    packageName = "SQLTools"
+    packageVersion = VERSION
+
+    @staticmethod
+    def debug(message):
+        if not Logger.isLogging():
+            return
+
+        print ("%s (%s): %s" % (Logger.packageName,
+                                Logger.packageVersion,
+                                message))
+
+    @staticmethod
+    def setLogging(param):
+        Logger.logging = param
+        Log('Logging is active')
+
+    @staticmethod
+    def isLogging():
+        return Logger.logging
+
+    @staticmethod
+    def setPackageName(param):
+        Logger.packageName = param
+
+    @staticmethod
+    def getPackageName():
+        return Logger.packageName
+
+    @staticmethod
+    def setPackageVersion(param):
+        Logger.packageVersion = param
+
+    @staticmethod
+    def getPackageVersion():
+        return Logger.packageVersion
+
+
+def Log(message):
+    return Logger.debug(message)

SQLToolsAPI/Log.py

@@ -0,0 +1,3 @@
+## SQLTools API for plugins - v0.0.2
+
+Docs will be ready soon