Eric Assistant: comparison AssistantEric/APIsManager.py

-:eac390ad0c2e
+:468560828f55
 SELECT id FROM file WHERE file = :file
 """
 file_delete_id_stmt = """
 DELETE FROM file WHERE id = :id
 """
-def __init__(self, proxy, language, apiFiles, projectPath="",
+api_files_stmt = """
+SELECT file FROM file
+"""
+def __init__(self, proxy, language, apiFiles, dbName, projectPath="",
 refresh=False, projectType=""):
 """
 Constructor
 @param proxy reference to the object that is proxied
 @type DbAPIs
 @param language language of the APIs object
 @type str
 @param apiFiles list of API files to process
 @type list of str
+@param dbName path name of the database file
+@type str
 @param projectPath path of the project. Only needed, if the APIs
 are extracted out of the sources of a project.
 @type str
 @param refresh flag indicating a refresh of the APIs of one file
 @type bool
 self.__apiFiles = apiFiles[:]
 self.__aborted = False
 self.__projectPath = projectPath
 self.__refresh = refresh
+self.__databaseName = dbName
 if self.__projectType:
+self.__connectionName = "{0}_{1}_{2}".format(
+self.__language, self.__projectType, id(self))
+else:
 self.__connectionName = "{0}_{1}".format(
-self.__language, self.__projectType)
+self.__language, id(self))
-else:
-self.__connectionName = self.__language
 def __autoCompletionWordSeparators(self, language):
 """
 Private method to get the word separator characters for a language.
 @param language language of the APIs object (string)
 @return word separator characters (list of strings)
 """
-return self.__wseps.get(language, None)
+if language:
+return self.__wseps.get(language, None)
+else:
+return self.__proxy.autoCompletionWordSeparators()
 def abort(self):
 """
 Public method to ask the thread to stop.
 """
 query.exec_()
 if query.next() and query.isValid():    # __IGNORE_WARNING_M513__
 loadTime = QDateTime.fromString(query.value(0), Qt.ISODate)
 else:
 loadTime = QDateTime(1970, 1, 1, 0, 0)
+query.finish()
 del query
 finally:
 db.commit()
 if self.__projectPath:
 modTime = QFileInfo(os.path.join(self.__projectPath, apiFile))\
 query.prepare(self.update_file_stmt)
 query.bindValue(":lastRead", QDateTime.currentDateTime())
 query.bindValue(":file", apiFile)
 query.exec_()
 finally:
+query.finish()
 del query
 if self.__aborted:
 db.rollback()
 else:
 db.commit()
 @param apis list of api entries (list of strings)
 @param bases list of base class entries (list of strings)
 @param apiFile filename of the file read to get the APIs (string)
 @param language programming language of the file of the APIs (string)
 """
-if language:
+wseps = self.__autoCompletionWordSeparators(language)
-wseps = self.__autoCompletionWordSeparators(language)
-else:
-wseps = self.__proxy.autoCompletionWordSeparators()
 if wseps is None:
 return
 db = QSqlDatabase.database(self.__connectionName)
 db.transaction()
 query.prepare(self.update_file_stmt)
 query.bindValue(":lastRead", QDateTime.currentDateTime())
 query.bindValue(":file", apiFile)
 query.exec_()
 finally:
+query.finish()
 del query
 if self.__aborted:
 db.rollback()
 else:
 db.commit()
 # step 4: delete the file entry
 query.prepare(self.file_delete_id_stmt)
 query.bindValue(":id", fileId)
 query.exec_()
 finally:
+query.finish()
 del query
 db.commit()
+def __getApiFiles(self):
+"""
+Private method to get a list of API files loaded into the database.
+@return list of API filenames
+@rtype list of str
+"""
+apiFiles = []
+db = QSqlDatabase.database(self.__connectionName)
+db.transaction()
+try:
+query = QSqlQuery(db)
+query.exec_(self.api_files_stmt)
+while query.next():                     # __IGNORE_WARNING_M513__
+apiFiles.append(query.value(0))
+finally:
+query.finish()
+del query
+db.commit()
+return apiFiles
 def run(self):
 """
 Public method to perform the threads work.
 """
 self.processing.emit(WorkerStatusStarted, "")
-db = QSqlDatabase.database(self.__connectionName)
+db = QSqlDatabase.addDatabase("QSQLITE", self.__connectionName)
+db.setDatabaseName(self.__databaseName)
+db.open()
 if db.isValid() and db.isOpen():
 # step 1: remove API files not wanted any longer
 if not self.__refresh:
-loadedApiFiles = self.__proxy.getApiFiles()
+loadedApiFiles = self.__getApiFiles()
 for apiFile in loadedApiFiles:
 if not self.__aborted and apiFile not in self.__apiFiles:
 self.__deleteApiFile(apiFile)
 # step 2: (re-)load api files
 for apiFile in self.__apiFiles:
 if not self.__aborted:
 self.__loadApiFileIfNewer(apiFile)
+db.close()
 if self.__aborted:
 self.processing.emit(WorkerStatusAborted, "")
 else:
 self.processing.emit(WorkerStatusFinished, "")
 self.__worker.wait(5000)
 if QSqlDatabase and QSqlDatabase.database(
 self.__connectionName).isOpen():
 QSqlDatabase.database(self.__connectionName).close()
-QSqlDatabase.removeDatabase(self.__language)
+for connectionName in QSqlDatabase.connectionNames():
+QSqlDatabase.removeDatabase(connectionName)
 self.__opened = False
 def __openApiDb(self):
 """
 query.exec_(self.create_context_idx)
 query.exec_(self.create_fullContext_idx)
 query.exec_(self.create_bases_idx)
 query.exec_(self.create_file_idx)
 finally:
+query.finish()
 del query
 db.commit()
 def getApiFiles(self):
 """
 query = QSqlQuery(db)
 query.exec_(self.api_files_stmt)
 while query.next():                     # __IGNORE_WARNING_M513__
 apiFiles.append(query.value(0))
 finally:
+query.finish()
 del query
 db.commit()
 return apiFiles
 query.next()                    # __IGNORE_WARNING_M513__
 formatVersion = int(query.value(0))
 if formatVersion >= self.DB_VERSION:
 prepared = True
 finally:
+query.finish()
 del query
 db.commit()
 return prepared
 def getCompletions(self, start=None, context=None, followHierarchy=False):
 query.exec_()
 while query.next():             # __IGNORE_WARNING_M513__
 completions.append({"completion": query.value(0),
 "context": query.value(1),
 "pictureId": query.value(2)})
+query.finish()
 del query
 finally:
 db.commit()
 if followHierarchy:
 else:
 bases = []
 for base in bases:
 completions.extend(self.getCompletions(start, base,
 followHierarchy=True))
+query.finish()
+del query
 return completions
 def getCalltips(self, acWord, commas, context=None, fullContext=None,
 showContext=True, followHierarchy=False):
 fullCtx,
 contextSeparator if fullCtx else "",
 word, sig))
 else:
 calltips.append("{0}{1}".format(word, sig))
+query.finish()
 del query
 finally:
 db.commit()
 if followHierarchy:
 bases = []
 for base in bases:
 calltips.extend(self.getCalltips(
 acWord, commas, context=base, showContext=showContext,
 followHierarchy=True))
+query.finish()
+del query
 if context and len(calltips) == 0 and not followHierarchy:
 # nothing found, try without a context
 calltips = self.getCalltips(
 acWord, commas, showContext=showContext)
 except TypeError:
 # older interface
 apiFiles = Preferences.getEditorAPI(self.__language)
 projectType = self.__projectType
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles,
-projectPath, projectType=projectType)
+self._apiDbName(), projectPath,
+projectType=projectType)
 self.__worker.processing.connect(
 self.__processingStatus, Qt.QueuedConnection)
 self.__worker.start()
 def __processQueue(self):
 projectType = ""
 else:
 projectPath = ""
 projectType = self.__projectType
 self.__worker = DbAPIsWorker(self, self.__language, apiFiles,
-projectPath, projectType=projectType,
+self._apiDbName(), projectPath,
-refresh=True)
+projectType=projectType, refresh=True)
 self.__worker.processing.connect(
 self.__processingStatus, Qt.QueuedConnection)
 self.__worker.start()
 def getLexer(self):

Mercurial Repositories > Eric Assistant / file comparison

comparison: AssistantEric/APIsManager.py

AssistantEric/APIsManager.py