@SGaist
This is a question about the C++ source code/behaviour. I do not presently have a case which goes wrong, but I am concerned there may be such a case. I am not able to check every call in every combination, hence the question about the source code.
However, since you are kind enough to respond, here is outline Python code for the situation:
import sys
import typing
from PyQt5 import QtCore, QtWidgets, QtGui
class MySqlQueryModel(QtGui.QSqlQueryModel):
def data(self, index: QtCore.QModelIndex, role: QtCore.Qt.ItemDataRole = QtCore.Qt.DisplayRole) -> typing.Any:
return super().data(index, role)
def setData(self, index: QtCore.QModelIndex, value: typing.Any, role: QtCore.Qt.ItemDataRole = QtCore.Qt.EditRole) -> bool:
return super().setData(index, value, role)
class Main(QtWidgets.QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle("Main")
self.setGeometry(100, 100, 500, 500)
self.centralWidget = QtWidgets.QWidget(self)
self.setCentralWidget(self.centralWidget)
self.centralLayout = QtWidgets.QHBoxLayout(self.centralWidget)
# create a QTableView
self.table = QtWidgets.QTableView()
self.centralLayout.addWidget(self.table)
# create a QSqlModel, and set it as view's model
self.model = MySqlQueryModel()
# set up a (MySQL) database connection
# `my_table` has `col1` which is/can be NULL and `col2` which is/can be non-NULL
self.model.setQuery("SELECT col1, col2 FROM my_table WHERE col1 IS NULL AND col2 IS NOT NULL")
# or perhaps just the following:
# self.model.setQuery("SELECT NULL AS col1, 'something-non-NULL' AS col2")
self.table.setModel(self.model)
self.show()
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
main = Main()
sys.exit(app.exec_())
Note the following:
Here I am overriding QSqlQueryModel. If it makes a difference, I am doing exactly the same for QSqlTableModel & QSqlRelationalTableModel.
The overridden data() & setData() methods are straight pass-throughs to the base C++ methods, but via Python/PyQt. If my code were C++ instead of Python/PyQt there would be no issue.
My question is about the behaviour of the C++ QVariant returned by, say, QSqlQueryModel::data() and the C++ QVariant passed from the caller into QSqlQueryModel::setData().
My question is for all possible in-built roles (enum Qt::ItemDataRole) which might be passed to these methods, from Qt::DisplayRole through Qt::InitialSortOrderRole, inclusive, i.e. all the Qt defined Qt::ItemDataRoles, and not any kind of Qt::UserRole I might define. Thus it includes both true "data" roles (e.g. Qt::DisplayRole) and purely "appearance" roles (e.g. Qt::TextAlignmentRole).
My question concerns 2 "slightly odd" QVariant types/values:
The "invalid" QVariant. This is where QVariant::isValid() == false. I believe it can be created via plain QVariant().
The "null" QVariant. This is where QVariant::isNull() == true. I am unsure how it is created in C++.
Now, unlike C++, PyQt "maps/unmaps" these two to/from the same Python None type/value. The QVariant type is simply hidden from me. The author of PyQt states that this relies on "[a particular call] not needing to treat these two as distinguishable", which he believes "is 'mostly' the case". But he states he does not claim to know exactly what individual C++ methods might do in the way of distinguishing them.
So, my questions are:
In the case of the return value from any of the data() overrides, for any given ItemDataRole passed in are there any cases where it might return both an "invalid" and a "null" QVariant under certain circumstances, to mean different things? We are only interested in one, single role being able to return either/both of these, not in different roles where some return one and some return the other. This is because PyQt returns None to me for either/both cases, so I cannot distinguish.
In the case of the value passed into any of the setData() overrides, for any possible ItemDataRole passed in are there any cases where it would behave differently depending on whether an "invalid" or a "null" QVariant is passed in? This might mean they treat those differently such that it matters, or it might mean that they only accept one of two and error on the other. This is because I can only pass None from PyQt for either/both cases [it maps that to one of "invalid"/"null" QVariant (always the same), and I don't even know which of the two], so I cannot distinguish.
I trust that the above is a very clear statement of the issue I face when writing my code. I cannot try out every combination of roles & values for each method in every circumstance, so I am asking someone with knowledge of the code/C++ behaviour to help.
Thank you very much.
