def query(self):
"""
Returns the query instance for this widget.
:return <orb.Query> || <orb.QueryCompound>
"""
queryWidget = self.queryWidget()
# check to see if there is an active container for this widget
container = queryWidget.containerFor(self)
if container:
return container.query()
elif QueryCompound.typecheck(self._query):
return self._query
# generate a new query from the editor
column = self.uiColumnDDL.currentSchemaPath()
plugin = self.currentPlugin()
editor = self.editor()
op = self.uiOperatorDDL.currentText()
if column and plugin:
query = Query(column)
plugin.setupQuery(query, op, editor)
return query
else:
return Query()
def query(self):
"""
Builds the query for this quick filter.
:return <orb.Query>
"""
output = Query()
for column, op, plugin, editor in self._plugins:
query = Query(column)
if plugin.setupQuery(query, op, editor):
output &= query
return output
def setTableType(self, tableType):
"""
Sets the table type for this instance to the given type.
:param tableType | <orb.Table>
"""
if tableType == self._tableType:
return
self._tableType = tableType
self.setQuery(Query())
def currentQuery(self):
"""
Returns the current query for the active container. This will reflect
what is currently visible to the user.
:return <orb.Query>
"""
container = self.currentContainer()
if container:
return container.query()
return Query()
def query(self):
"""
Returns the full query for this widget. This will reflect the complete
combined query for all containers within this widget.
:return <orb.Query>
"""
if self._loadQuery is not None:
return self._loadQuery
container = self.widget(0)
if container:
return container.query()
return Query()
def removeEntry(self, entry):
if not entry:
return
layout = self._entryWidget.layout()
if layout.count() == 2:
entry.setQuery(Query())
return
layout.takeAt(layout.indexOf(entry))
entry.close()
if not self.signalsBlocked():
self.entriesUpdated.emit()
def query(self):
"""
Returns the query that is defined by this current panel.
:return <orb.Query>
"""
joiner = self.currentJoiner()
query = Query()
for entry in self.entries():
if joiner == QueryCompound.Op.And:
query &= entry.query()
else:
query |= entry.query()
query.setName(self.uiNameTXT.text())
return query
def addEntry(self, query=None, entry=None):
if query is None:
query = Query()
layout = self._entryWidget.layout()
index = layout.count() - 1
if entry:
index = layout.indexOf(entry) + 1
widget = XOrbQueryEntryWidget(self, self.tableType())
layout.insertWidget(index, widget)
widget.setQuery(query)
if not self.signalsBlocked():
self.entriesUpdated.emit()
return widget
def createCompoundFromChecked(self):
"""
Creates a new compound query from the checked entry list.
:return <orb.QueryCompound>
"""
checked_entries = self.checkedEntries()
if len(checked_entries) <= 1:
return QueryCompound()
self.setUpdatesEnabled(False)
joiner = self.currentJoiner()
query = Query()
for entry in checked_entries:
if joiner == QueryCompound.Op.And:
query &= entry.query()
else:
query |= entry.query()
# clear out the existing containers
first = checked_entries[0]
first.setQuery(query)
first.setChecked(False)
layout = self._entryWidget.layout()
for i in range(len(checked_entries) - 1, 0, -1):
w = checked_entries[i]
layout.takeAt(layout.indexOf(w))
w.close()
self.refreshEntries()
self.setUpdatesEnabled(True)
if not self.signalsBlocked():
self.enterCompound(first, query)
def showEvent(self, event):
if self._loadQuery is not None:
self.setQuery(self._loadQuery)
elif not self._initialized:
self.setQuery(Query())
def reset(self):
"""
Resets this query builder to a blank query.
"""
self.setQuery(Query())
