Python Pireal.get_service方法代码示例

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def execute_queries(self, query=''):
        """ This function executes queries """

        # Hide tooltip if visible
        if QToolTip.isVisible():
            QToolTip.hideText()

        # If text is selected, then this text is the query,
        # otherwise the query is all text that has the editor
        editor_widget = self.currentWidget().get_editor()
        if editor_widget.textCursor().hasSelection():
            query = editor_widget.textCursor().selectedText()
        else:
            query = editor_widget.toPlainText()

        relations = self.currentWidget().relations
        central = Pireal.get_service("central")
        table_widget = central.get_active_db().table_widget

        # Restore
        relations.clear()
        self.currentWidget().clear_results()

        # Parse query
        sc = scanner.Scanner(query)
        lex = lexer.Lexer(sc)
        try:
            par = parser.Parser(lex)
            interpreter = parser.Interpreter(par)
            interpreter.clear()
            interpreter.to_python()
        except Exception as reason:
            pireal = Pireal.get_service("pireal")
            pireal.show_error_message(self.parse_error(reason.__str__()))
            return
        relations.update(table_widget.relations)
        for relation_name, expression in list(interpreter.SCOPE.items()):
            if relation_name in relations:
                QMessageBox.critical(self,
                                     self.tr("Query Error"),
                                     self.tr("<b>{}</b> is a duplicate "
                                             "relation name.<br><br> "
                                             "Please choose a unique name "
                                             "and re-execute the "
                                             "queries.".format(
                                                 relation_name)))
                del interpreter.SCOPE[relation_name]
                return
            try:
                new_relation = eval(expression, {}, relations)

            except Exception as reason:
                pireal = Pireal.get_service("pireal")
                pireal.show_error_message(self.parse_error(reason.__str__()),
                                          syntax_error=False)
                return

            relations[relation_name] = new_relation
            self.__add_table(new_relation, relation_name)

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
 def execute_queries(self):
     # Editor instance
     query_editor = Pireal.get_service("query-editor").editor
     query = query_editor.toPlainText()  # Text
     # Parse query
     expression = parser.convert_to_python(query)
     table_widget = Pireal.get_service("db")
     rel = eval(expression, table_widget.relations)

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
 def add_table(self, rela, rname):
     central_widget = Pireal.get_service("central")
     lateral_widget = Pireal.get_service("lateral_widget")
     db = central_widget.get_active_db()
     _view = db.create_table(rela, rname, editable=False)
     table_widget = central_widget.get_active_db().table_widget
     index = table_widget.stacked_result.addWidget(_view)
     table_widget.stacked_result.setCurrentIndex(index)
     lateral_widget.result_list.add_item(
         rname, rela.cardinality(), rela.degree())
     # lateral_widget.result_list.select_last()
     table_widget._tabs.setCurrentIndex(1)

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def new_query(self, filename=''):
        query_widget = Pireal.get_service("query_widget")
        self.addWidget(query_widget)
        if not query_widget.isVisible():
            query_widget.show()
        pireal = Pireal.get_service("pireal")
        pireal.enable_disable_query_actions()
        query_widget.new_query(filename)

        self.connect(query_widget,
                     SIGNAL("currentEditorSaved(QPlainTextEdit)"),
                     self.save_query)

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
 def new_query(self):
     from src.gui.query_editor import query_widget
     widget = query_widget.QueryWidget()
     pireal = Pireal.get_service("pireal")
     # Load the instance
     Pireal.load_service("query-editor", widget)
     # MdiArea
     mdi = Pireal.get_service("mdi")
     widget.setMinimumSize(mdi.width(), mdi.minimumSizeHint().height())
     mdi.addSubWindow(widget)
     # Enable querie's QAction
     pireal.enable_disable_query_actions()
     widget.show()

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
 def clear_results(self):
     central_widget = Pireal.get_service("central")
     lateral_widget = Pireal.get_service("lateral_widget")
     lateral_widget.result_list.clear_items()
     table_widget = central_widget.get_active_db().table_widget
     i = table_widget.stacked_result.count()
     # i = self._stack_tables.count()
     while i >= 0:
         # widget = self._stack_tables.widget(i)
         widget = table_widget.stacked_result.widget(i)
         # self._stack_tables.removeWidget(widget)
         table_widget.stacked_result.removeWidget(widget)
         if widget is not None:
             widget.deleteLater()
         i -= 1

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
 def create_data_base(self):
     mdi = Pireal.get_service("mdi")
     db_name, ok = QInputDialog.getText(mdi, self.tr("New DB"),
                                        self.tr("Name:"),
                                        text=getpass.getuser())
     if ok:
         from src.gui import table_widget
         db_widget = table_widget.MdiDB()
         db_widget.setWindowTitle(db_name + '.pdb')
         db_widget.setMinimumSize(mdi.width(), mdi.height() / 1.7)
         mdi.addSubWindow(db_widget)
         # Enable QAction's
         pireal = Pireal.get_service("pireal")
         pireal.enable_disable_db_actions()
         db_widget.show()

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def __on_wizard_finished(self, data, wizard_widget):
        """ This slot execute when wizard to create a database is finished """

        pireal = Pireal.get_service("pireal")
        if not data:
            # If it's canceled, remove wizard widget and return to Start Page
            self.remove_last_widget()
        else:
            # Create a new data base container
            db_container = database_container.DatabaseContainer()
            # Associate the file name with the PFile object
            pfile_object = pfile.File(data['filename'])
            # Associate PFile object with data base container
            # and add widget to stacked
            db_container.pfile = pfile_object
            self.add_widget(db_container)
            # Remove wizard
            self.stacked.removeWidget(wizard_widget)
            # Set window title
            pireal.change_title(file_manager.get_basename(data['filename']))
            # Enable db actions
            pireal.set_enabled_db_actions(True)
            pireal.set_enabled_relation_actions(True)
            self.created = True
            DEBUG("Base de datos creada correctamente: '{}'".format(
                data['filename']))

        # If data or not, show menubar and toolbar again
        pireal.show_hide_menubar()
        pireal.show_hide_toolbar()

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def add_new_table(self, rel, name):
        import itertools

        table = QTableWidget()
        table.setRowCount(0)
        table.setColumnCount(0)

        data = itertools.chain([rel.fields], rel.content)

        for row_data in data:
            row = table.rowCount()
            table.setColumnCount(len(row_data))
            for col, text in enumerate(row_data):
                item = QTableWidgetItem()
                item.setText(text)
                if row == 0:
                    table.setHorizontalHeaderItem(col, item)
                else:
                    table.setItem(row - 1, col, item)
            table.insertRow(row)
        table.removeRow(table.rowCount() - 1)
        self.stacked.addWidget(table)
        self.stacked.setCurrentIndex(self.stacked.count() - 1)
        lateral = Pireal.get_service("lateral")
        lateral.add_item_list([name])

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def execute_queries(self):
        import re
        # Editor instance
        editor = self.tab.currentWidget()
        # Text
        text = editor.toPlainText()
        # Ignore comments
        table = Pireal.get_service("container").table_widget
        for line in text.splitlines():
            if line.startswith('--'):
                continue
            parts = line.split('=', 1)
            parts[0] = parts[0].strip()
            if re.match(r'^[_a-zA-Z]+[_a-zA-Z0-9]*$', parts[0]):
                relation_name, line = parts
            else:
                relation_name = 'rel_{}'.format(self.__nrelation)
                self.__nrelation += 1
            try:
                expression = parser.convert_to_python(line.strip())
                rel = eval(expression, table.relations)
            except Exception as reason:

            #try:
            #except Exception as reason:
                QMessageBox.critical(self, self.tr("Error en consulta"),
                                     reason.__str__())
                return
            table.add_new_table(rel, relation_name)
            table.relations[relation_name] = rel

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def _check_count(self):
        """ Hide dock if count = 0 """

        if self.tab.count() == 0:
            pireal = Pireal.get_service("pireal")
            pireal.enable_disable_query_actions(False)
            self.hide()

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
 def __hide(self):
     if self.count() == 0:
         self.hide()
         # Disable query actions
         pireal = Pireal.get_service("pireal")
         pireal.set_enabled_query_actions(False)
         pireal.set_enabled_editor_actions(False)

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def add_data_base(self, data):
        lateral = Pireal.get_service("lateral")
        rel = None
        for part in data.split('@'):
            for e, line in enumerate(part.splitlines()):
                if e == 0:
                    name = line.split(':')[0]
                    rel = relation.Relation()
                    rel.fields = line.split(':')[-1].split(',')
                else:
                    rel.insert(line.split(','))
            if rel is not None:
                table = Table()
                table.setRowCount(1)
                table.setColumnCount(0)
                self.relations[name] = rel

                for _tuple in rel.content:
                    row = table.rowCount()
                    table.setColumnCount(len(rel.fields))
                    for column, text in enumerate(_tuple):
                        item = Item()
                        item.setText(text)
                        table.setItem(row - 1, column, item)
                    table.insertRow(row)
                table.setHorizontalHeaderLabels(rel.fields)
                self.stacked.addWidget(table)
                table.removeRow(table.rowCount() - 1)
                lateral.add_item_list([name])

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
 def __open_example(self):
     central_widget = Pireal.get_service("central")
     db_filename = os.path.join(settings.EXAMPLES, 'database.pdb')
     central_widget.open_database(filename=db_filename, remember=False)
     query_filename = os.path.join(settings.EXAMPLES, 'queries.pqf')
     central_widget.open_query(filename=query_filename, remember=False)
     # Ejecuto las consultas de ejemplo luego de 1.3 segundos
     QTimer.singleShot(1300, central_widget.execute_queries)

# 需要导入模块: from src.gui.main_window import Pireal [as 别名]
# 或者: from src.gui.main_window.Pireal import get_service [as 别名]
    def execute_queries(self, query=''):
        """ This function executes queries """

        # If text is selected, then this text is the query,
        # otherwise the query is all text that has the editor
        editor_widget = self.currentWidget().get_editor()
        if editor_widget.textCursor().hasSelection():
            query = "\n".join(
                editor_widget.textCursor().selectedText().splitlines())
        else:
            query = editor_widget.toPlainText()
        relations = self.currentWidget().relations
        central = Pireal.get_service("central")
        table_widget = central.get_active_db().table_widget

        # Restore
        relations.clear()
        self.currentWidget().clear_results()

        editor_widget.show_run_cursor()

        # Parse query
        error = True
        try:
            result = parser.parse(query)
        except MissingQuoteError as reason:
            title = self.tr("Error de Sintáxis")
            text = self.parse_error(str(reason))
        except InvalidSyntaxError as reason:
            title = self.tr("Error de Sintáxis")
            text = self.parse_error(str(reason) + "\n" + self.tr(
                "El error comienza con " + reason.character))
        except DuplicateRelationNameError as reason:
            title = self.tr("Nombre duplicado")
            text = self.tr("Ya existe una relación con el nombre <b>{}</b> :(."
                           "<br><br>Elige otro por favor ;).".format(
                               reason.rname))
        except ConsumeError as reason:
            title = self.tr("Error de Sintáxis")
            text = self.parse_error(str(reason))
        else:
            error = False
        if error:
            QMessageBox.critical(self, title, text)
            return
        relations.update(table_widget.relations)
        for relation_name, expression in result.items():
            try:
                new_relation = eval(expression, {}, relations)
            except Exception as reason:
                QMessageBox.critical(
                    self,
                    self.tr("Error de Consulta"),
                    self.parse_error(str(reason))
                )
                return
            relations[relation_name] = new_relation
            self.__add_table(new_relation, relation_name)