MySQL 显示数据 mysql显示表中的数据

转载

mob64ca1403528a 2023-10-30 19:27:45

文章标签 MySQL 显示数据 qt 不显示 mysql 数据表中的内容数据库结果集 #include 文章分类 MySQL 数据库

整理一下 QT 操作数据库的一些要点，以备以后的查询学习(主要是操作 mysql )。

首先，要查询相关的驱动是否已经装好了，可以用以下的程序进行验证：

#include 
#include 
#include 
#include 
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
qDebug()<
QStringList drivers = QSqlDatabase::drivers();
foreach(QString driver, drivers)
qDebug() <
return a.exec();
}
结果如下：
接着是连接数据库：
#include 
#include 
#include 
bool createConnection()
{
QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL");
db.setDatabaseName("test");
db.setUserName("root");
db.setPassword("123456");
bool ok = db.open();
if(!ok){
QMessageBox::critical(0, QObject::tr(" 连接数据库失败！！！ "), db.lastError().text());
return false;
}else{
QMessageBox::information(0, QObject::tr("Tips"), QObject::tr(" 连接数据库成功！！！ "));
return true;
}
}
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QTextCodec *codec= QTextCodec::codecForName("GB2312");
QTextCodec::setCodecForLocale(codec);
QTextCodec::setCodecForCStrings(codec);
QTextCodec::setCodecForTr(codec);
if(!createConnection())
return 1;
return a.exec();
}

结果如下：

插入操作：

//ODBC数据库表示方式
QSqlQuery query;
query.prepare( “insert into student (id, name) ”
“values (:id, :name) ”);
query.bindValue(0, 5);
query.bindValue(1, “sixth ”);
query.exec();
//Oracle表示方式
query.prepare( “insert into student (id, name) ”
“values (?, ?) ”);
query.bindValue(0, 5);
query.bindValue(1, “sixth ”);
query.exec();
//使用 addBindValue()函数，省去了编号，它是按属性顺序赋值的
query.prepare( “insert into student (id, name) ”
“values (?, ?) ”);
query.addBindValue(5);
query.addBindValue( “sixth ”);
query.exec();
//使用 ODBC方法时，可以将编号用实际的占位符代替
query.prepare( “insert into student (id, name) ”
“values (:id, :name) ”);
query.bindValue( “:id ”, 5);
query.bindValue( “:name ”, “sixth ”);
query.exec();

注意：最后一定要执行 exec() ，否则上面的语句是不会被执行的。

//进行多个记录的插入时，可以利用绑定进行批处理
QSqlQuery q;
q.prepare( “insert into student values (?, ?) ”);
QVariantList ints;
ints << 10 << 11 << 12 << 13;
q.addBindValue(ints);
QVariantList names;
names <
// 最后一个是空字符串，应与前面的格式相同
q.addBindValue(names);
if (!q.execBatch()) // 进行批处理，如果出错就输出错误
qDebug() << q.lastError();

查询操作：

//返回全部的属性和结果集
QSqlQuery query;
query.exec( “select * from student ”);// 执行查询操作
qDebug() <
if(query.next())
// 开始就先执行一次next() 函数，那么query 指向结果集的第一条记录
{
int rowNum = query.at();
// 获取query 所指向的记录在结果集中的编号
int columnNum = query.record().count();
// 获取每条记录中属性(即列)的个数
int fieldNo = query.record().indexOf( “name ”);
// 获取 ” name ”属性所在列的编号，列从左向右编号，最左边的编号为 0
int id = query.value(0).toInt();
// 获取id 属性的值，并转换为int 型
QString name = query.value(fieldNo).toString();
// 获取name 属性的值
qDebug() <
<
<
<
}
qDebug() <
if(query.seek(2))
// 定位到结果集中编号为2 的记录，即第三条记录，因为第一条记录的编号为 0
{
qDebug() <
<
<
}
qDebug() <
if(query.last())
// 定位到结果集中最后一条记录
{
qDebug() <
<
<
}

结果集其实就是查询到的所有记录的集合，而在QSqlQuery 类中提供了多个函数来操作这个集合，需要注意这个集合中的记录是从0开始编号的。最常用的有：

seek(int n)：query 指向结果集的第n 条记录。

first()：query 指向结果集的第一条记录。

last()：query 指向结果集的最后一条记录。

next()：query 指向下一条记录，每执行一次该函数，便指向相邻的下一条记录。

previous()：query 指向上一条记录，每执行一次该函数，便指向相邻的上一条记录。

record()：获得现在指向的记录。

value(int n)：获得属性的值。其中n 表示你查询的第n 个属性，比方上面我们使用 “ select * from student ”就相当于 “ select id, name from student ”，那么value(0) 返回id 属性的值，value(1) 返回name 属性的值。该函数返回QVariant 类型的数据，关于该类型与其他类型的对应关系，可以在帮助中查看QVariant 。

at()：获得现在query 指向的记录在结果集中的编号。

需要说明，当刚执行完query.exec( “select * from student ”); 这行代码时，query 是指向结果集以外的，我们可以利用query.next() ，当第一次执行这句代码时，query 便指向了结果集的第一条记录。当然我们也可以利用seek(0) 函数或者first() 函数使query 指向结果集的第一条记录。但是为了节省内存开销，推荐的方法是，在query.exec( “select * from student ”); 这行代码前加上query.setForwardOnly(true); 这条代码，此后只能使用next() 和seek() 函数。

//满足一定条件的结果集，方法一
QSqlQuery query;
query.prepare( “select name from student where id = ? ”);
int id =2; // 从界面获取id 的值
query.addBindValue(id); // 将id 值进行绑定
query.exec();
query.next(); // 指向第一条记录
qDebug() << query.value(0).toString();
//方法二
QSqlQuery query;
query. exec( QObject :: tr( "select * from student where id = %1" ). arg( 2 ));
if (! query. next())
qDebug()<
else
qDebug()<

事务是数据库的一个重要功能，所谓事务是用户定义的一个数据库操作序列，这些操作要么全做要么全不做，是一个不可分割的工作单位。在Qt 中用transaction() 开始一个事务操作，用commit() 函数或rollback() 函数进行结束。commit() 表示提交，即提交事务的所有操作。具体地说就是将事务中所有对数据库的更新写回到数据库，事务正常结束。rollback()表示回滚，即在事务运行的过程中发生了某种故障，事务不能继续进行，系统将事务中对数据库的所有已完成的操作全部撤销，回滚到事务开始时的状态。

QSqlQuery query;
if(QSqlDatabase::database().transaction()) // 启动事务操作
{
// 下面执行各种数据库操作
query.exec( “insert into student values (14, ‘hello’) ”);
query.exec( “delete from student where id = 1 ″);
//
if(!QSqlDatabase::database().commit())
{
qDebug() << QSqlDatabase::database().lastError(); // 提交
if(!QSqlDatabase::database().rollback())
qDebug() << QSqlDatabase::database().lastError(); // 回滚
}
}
// 输出整张表
query.exec( “select * from student ”);
while(query.next())
qDebug() << query.value(0).toInt() << query.value(1).toString();

Qt中使用了自己的机制来避免使用SQL 语句，它为我们提供了更简单的数据库操作和数据显示模型。它们分别是只读的QSqlQueryModel ，操作单表的QSqlTableModel 和以及可以支持外键的QSqlRelationalTableModel

// QSqlQueryModel
QSqlQueryModel *model = new QSqlQueryModel;
model->setQuery( “select * from student ”);
model->setHeaderData(0, Qt::Horizontal, tr( “id ”));
model->setHeaderData(1, Qt::Horizontal, tr( “name ”));
QTableView *view = new QTableView;
view->setModel(model);
view->show();
//QSqlTableModel
QSqlTableModel *model;
model = new QSqlTableModel(this);
model->setTable( “student ”);
model->setEditStrategy(QSqlTableModel::OnManualSubmit);
model->select(); // 选取整个表的所有行
// model->removeColumn(1); // 不显示name 属性列 , 如果这时添加记录，则该属性的值添加不上
ui->tableView->setModel(model);
// ui->tableView->setEditTriggers(QAbstractItemView::NoEditTriggers);   // 使其不可编辑
//过滤
model->setFilter(QObject::tr(“name = ‘%1 ′”).arg(name)); // 根据姓名进行筛选
model->select(); // 显示结果
//删除操作
int curRow = ui->tableView->currentIndex().row();
// 获取选中的行
model->removeRow(curRow);
// 删除该行
int ok = QMessageBox::warning(this,tr( “删除当前行! ”),tr( “你确定 ”
“删除当前行吗？ ” ),
QMessageBox::Yes,QMessageBox::No);
if(ok == QMessageBox::No)
{
model->revertAll(); // 如果不删除，则撤销
}
else
model->submitAll(); // 否则提交，在数据库中删除该行
//插入操作
int rowNum = model->rowCount(); // 获得表的行数
int id = 10;
model->insertRow(rowNum); // 添加一行
model->setData(model->index(rowNum,0),id);
model->submitAll();// 记得提交
//QSqlRelationalTableModel
//create table student (id int primary key, name vchar,course int)
// create table course (id int primary key, name vchar, teacher vchar)
model = new QSqlRelationalTableModel(this);
model->setEditStrategy(QSqlTableModel::OnFieldChange); // 属性变化时写入数据库
model->setTable( “student ”);
model->setRelation(2,QSqlRelation( “course ”, ”id ”, ”name ”));
// 将student 表的第三个属性设为course 表的id 属性的外键，并将其显示为course 表的name 属性的值
model->setHeaderData(0, Qt::Horizontal, QObject::tr( “ID ”));
model->setHeaderData(1, Qt::Horizontal, QObject::tr( “Name ”));
model->setHeaderData(2, Qt::Horizontal, QObject::tr( “Course ”));
model->select();
ui->tableView->setModel(model);

ui->tableView->setItemDelegate(new QSqlRelationalDelegate(ui->tableView));// 如果用户更改课程属性，那么他只能在课程表中有的课程中进行选择，而不能随意填写课程。在Qt 中的QSqlRelationalDelegate 委托类就能实现这个功能。我们只需添加一行代码

#include

QT += sql

QSqlDatabase类实现了数据库连接的操作

QSqlQuery类用来执行SQL语句

QSqlRecord类封装数据库所有记录

第一：QSqlDatabase类

QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE"); 采用QSQLITE数据库，QMYSQL数据库有问题？

db.setHostName("localhost"); //设置数据库主机名

db.setDatabaseName("test"); //设置数据库名

db.setUserName("root"); //设置数据库登入用户名

db.setPassword("123456"); //设计数据库登入密码

db.open()打开数据库连接

db.close();//释放数据库

QStringList drivers = QSqlDatabase::drivers();//静态成员函数，是类的成员函数，不是对象的.返回所有可用的数据库驱动程序的清单

drivers.removeAll("QMYSQL3"); //删除列表中的项

foreach(QString driver, drivers) //遍历数据库驱动，测试数据库驱动种类

qDebug() << “\t” << driver;

建立数据库文件

QSqlDatabase db = QSqlDatabase::addDatabase("QSQLITE");

db.setDatabaseName("database.db");

if(!db.open()) return false;

QSqlQuery query;

query.exec("create table Login(id INTEGER PRIMARY KEY autoincrement, " //id会自动增加，因为这里不能重复，否则数据库无法修改

"goods int, store int, time nvarchar(50), type int,  place nvarchar(50),temperature nvarchar(10) )");
//query.exec("insert into Login values(1,1002, 1,'2011-9-6',1,'common',24)");
// query.exec("insert into Login values(2,1005, 1,'2011-9-6',1,'common',24)");
//query.exec("insert into Login values(3,1010, 2,'2011-9-7',2,'common',25)");
//    query.exec("insert into Login values(4,1012, 2,'2011-9-7',2,'common',25)");
query.exec("insert into Login values( 1,NULL , NULL,NULL, NULL,NULL,NULL )");
query.exec("insert into Login values( 2,NULL , NULL,NULL, NULL,NULL,NULL )");
query.exec("insert into Login values( 3,NULL , NULL,NULL, NULL,NULL,NULL )");
query.exec("insert into Login values( 4,NULL , NULL,NULL, NULL,NULL,NULL )");
query.exec("insert into Login values( 5,NULL , NULL,NULL, NULL,NULL,NULL )");
query.exec("insert into Login values( 6,NULL , NULL,NULL, NULL,NULL,NULL )");
第二：QSqlQuery类，查询数据库，插入值到数据库等操作数据库
QSqlQuery query;
query.prepare("INSERT INTO T_USER (name, age) VALUES (:name, :age)"); //准备执行SQL查询
query.bindValue(":name", "justin");   //在这定占位符上确定绑定的值
query.bindValue(":age", 33);
query.exec();
QSqlQuery query; //以下执行相关QSL语句
query.exec(“create table student(id int primary key,name varchar)”);
//新建student表，id设置为主键，还有一个name项
query.exec(“insert into student values(1,’xiaogang’)”);
query.exec(“insert into student values(2,’xiaoming’)”);
query.exec(“insert into student values(3,’xiaohong’)”);
//向表中插入3条记录
query.exec(“select * from student”);

来查询出表中所有的内容。其中的SQL语句“select * from student”中“*”号表明查询表中记录的所有属性。而当query.exec(“select * from student”);

这条语句执行完后，我们便获得了相应的执行结果，因为获得的结果可能不止一条记录，所以我们称之为结果集。

while(query.next())

QString name = query.value(0).toString(); //返回"name"字段的索引值"justin",value(i)返回i字段的值，0表示name，1表示age

int id = query.value(1).toInt();

seek(int n) ：query指向结果集的第n条记录。指定当前的位置

first() ：query指向结果集的第一条记录。

last() ：query指向结果集的最后一条记录。

next() ：query指向下一条记录，每执行一次该函数，便指向相邻的下一条记录。

previous() ：query指向上一条记录，每执行一次该函数，便指向相邻的上一条记录。

record() ：获得现在指向的记录。

value(int n) ：获得属性的值。其中n表示你查询的第n个属性，比方上面我们使用“select * from student”就相当于“select id, name from student”，那么value(0)返回id属性的值，value(1)返回name属性的值。该函数返回QVariant类型的数据，关于该类型与其他类型的对应关系，可以在帮助中查看QVariant。

at()//返回当前查询的位置
int fieldNo = query.record().indexOf(“name”);//返回"name"的列号
int rowNum = query.at();
//获取query所指向的记录在结果集中的编号
int columnNum = query.record().count();
//获取每条记录中属性(即列)的个数
int fieldNo = query.record().indexOf(“name”);
//获取”name”属性所在列的编号，列从左向右编号，最左边的编号为0
int id = query.value(0).toInt();
//获取id属性的值，并转换为int型
QString name = query.value(fieldNo).toString();
//获取name属性的值
qDebug() << “rowNum is : ” << rowNum //将结果输出
<< ” id is : ” << id
<< ” name is : ” << name
<< ” columnNum is : ” << columnNum;
}
if(query.seek(2)) //seek指定当前的位置
if(query.seek(ui->spinBox->value()))
{
qDebug() << query.value(0).toInt() << query.value(1).toString();
while(query.next())  //每执行一次该函数，便指向相邻的下一条记录。
{
qDebug() << query.value(0).toInt() << query.value(1).toString(); //value(i)返回i字段的值，0表示id，1表示name
}
}
//批处理操作函数--批量插入到数据库中
QSqlQuery q;
q.prepare(“insert into student values (?, ?)”);
QVariantList ints;          //QVariantList==QList
ints << 10 << 11 << 12 << 13;
q.addBindValue(ints);   //绑定
QVariantList names;
names << “xiaoming” << “xiaoliang” << “xiaogang” << QVariant(QVariant::String);
//最后一个是空字符串，应与前面的格式相同
q.addBindValue(names);
if (!q.execBatch()) //进行批处理，如果出错就输出错误
qDebug() << q.lastError();
//事务操作--操作函数transaction()，commit()提交，rollback()回滚

事务是数据库的一个重要功能，所谓事务是用户定义的一个数据库操作序列，这些操作要么全做要么全不做，是一个不可分割的工作单位。

在Qt中用transaction()开始一个事务操作，用commit()函数或rollback()函数进行结束。commit()表示提交，即提交事务的所有操作。

具体地说就是将事务中所有对数据库的更新写回到数据库，事务正常结束。rollback()表示回滚，即在事务运行的过程中发生了某种故障，事务不能继续进行，

系统将事务中对数据库的所有已完成的操作全部撤销，回滚到事务开始时的状态。

if(QSqlDatabase::database().driver()->hasFeature(QSqlDriver::Transactions)) //先判断该数据库是否支持事务操作。hasFeature是QSQLDriver类函数

if(QSqlDatabase::database().transaction()) //启动事务操作

QModelIndex类 --用来定义数据模型中的数据

第三：QSqlQueryModel类只读数据模型为数据库结果集

函数：void QSqlQueryModel::setQuery ( const QString & query, const QSqlDatabase & db = QSqlDatabase() //执行访问query从给定的数据库db

setHeaderData() //设置水平头标题

columnCount(); //获得列数

QSqlRecord QSqlQueryModel::record ( int row ) const //返回row行包含的信息

QModelIndex QAbstractItemModel::index ( int row, int column, const QModelIndex & parent = QModelIndex() ) //返回指定的行和列的确定的那个索引(index)

index.data() //返回index索引的值

QSqlQueryModel *model = new QSqlQueryModel;
model->setQuery("select * from student");   //查询整个student表的内容，访问给定的数据库
model->setHeaderData(0, Qt::Horizontal, tr("id"));
model->setHeaderData(1, Qt::Horizontal, tr("name"));
QTableView *view = new QTableView;
view->setModel(model);  //重新定义模型，model直接从database.db的数据库中插入数据
view->show();

int column = model->columnCount(); //获得列数
int row = model->rowCount();    // 获得行数
QSqlRecord record = model->record(1); //获得一条记录
QModelIndex index = model->index(1,1);   //获得一条记录的一个属性的值
qDebug() << "column num is:" << column << endl
<< "row num is:" << row << endl
<
<

QSqlQuery query = model->query(); //返回与QSqlQuery相关的模型

query.exec("insert into student values (10,'yafei10')"); //在模型中插入一条记录

model->setQuery("select * from student"); //再次查询整张表

view->show(); //再次进行显示，这句也可以不写

4. 使QSqlQueryModel类创建的数据库能读写继承QAbstractItemModel类

刚开始我们就讲到，这个模型默认是只读的，所以我们在窗口上并不能对表格中的内容进行修改。但是我们可以创建自己的模型，然后按照我们自己的意愿来显示数据和修改数据。

要想使其可读写，需要自己的类继承自QSqlQueryModel，并且重写setData() 和 flags() 两个函数。如果我们要改变数据的显示，就要重写data() 函数。

bool QAbstractItemModel::setData ( const QModelIndex & index, const QVariant & value, int role = Qt::EditRole ) //设置根据index索引到的value值

Qt::ItemFlags QAbstractItemModel::flags ( const QModelIndex & index ) const //返回给定的index索引的标志

QVariant QAbstractItemModel::data ( const QModelIndex & index, int role = Qt::DisplayRole ) const //返回index和role(显示状态)确定的值

Qt::ItemFlags MySqlQueryModel::flags(
const QModelIndex &index) const //返回表格是否可更改的标志
{
Qt::ItemFlags flags = QSqlQueryModel::flags(index);
if (index.column() == 1) //第二个属性可更改
flags |= Qt::ItemIsEditable;  //flags能被编辑，所以第二列能被编辑
return flags;
}
QVariant MySqlQueryModel::data(const QModelIndex &index, int role) const
//更改数据显示样式
{
QVariant value = QSqlQueryModel::data(index, role);
if (role == Qt::TextColorRole && index.column() == 0)  //Qt::TextColorRole是确定颜色等为9，所以与之后是第一列
return qVariantFromValue(QColor(Qt::red)); //第一个属性的字体颜色为红色
return value;
}

第四：QSqlTableModel 继承QSqlQueryModel类 --该类提供了一个可读写单张SQL表的可编辑数据模型，功能：修改，插入，删除，查询，和排序

QSqlTableModel *model = new QSqlTableModel;

virtual bool removeColumns ( int column, int count, const QModelIndex & parent = QModelIndex() ) //model->removeColumns (0)删除第一列

bool QSqlTableModel::submitAll ()，//提交所有被修改的数据，然后修改的数据被保存在数据库中

void QSqlTableModel::revertAll () //撤销所有的修改，但是如果数据库已经被提交了修改，就不能通过撤销修改改回来了

void QSqlTableModel::setFilter ( const QString & filter ) //筛选，按照字符串filter对数据库进行筛选

bool QSqlTableModel::select () //在筛选和排序的条件下，将数据库中符合要求的在mode表格中显示出来

void QSqlTableModel::setSort ( int column, Qt::SortOrder order ) //排序操作。按照列和Qt::SortOrder排序。Qt::SortOrder有升序和降序

virtual void revertRow ( int row ) //删除行

bool insertRow ( int row, const QModelIndex & parent = QModelIndex() ) //插入行，也有插入列

model->setEditStrategy(QSqlTableModel::OnManualSubmit); //设置保存策略为手动提交，OnManualSubmit表明我们要提交修改才能使其生效。

1. //在tableview表格中显示数据库数据

model = new QSqlTableModel(this);

model->setTable("student"); //设置"student"的数据库表格

model->setEditStrategy(QSqlTableModel::OnManualSubmit); //设置保存策略为手动提交

model->select(); //选取整个表的所有行

// model->removeColumn(1); //不显示name属性列,如果这时添加记录，则该属性的值添加不上。

ui->tableView->setModel(model); //重新定义模型，model直接从database.db的数据库中插入数据

//ui->tableView->setEditTriggers(QAbstractItemView::NoEditTriggers); //使其不可编辑

2. //当tableview被修改后，要通过submitAll()函数进行保存 bool QSqlTableModel::submitAll ()，提交所有被修改的数据，然后修改的数据被保存在数据库中

model->database().transaction(); //开始事务操作
if (model->submitAll()) {   //提交所有被修改的数据，然后修改的数据被保存在数据库中
model->database().commit(); //提交
} else {
model->database().rollback(); //回滚
QMessageBox::warning(this, tr(“tableModel”),
tr(“数据库错误: %1″)
.arg(model->lastError().text()));
}

model->revertAll(); //撤销修改

3. 查询操作--void QSqlTableModel::setFilter ( const QString & filter ) //筛选

QString name = ui->lineEdit->text();

model->setFilter(QObject::tr(“name = ‘%1′”).arg(name)); //根据姓名进行筛选

model->select(); //显示结果

4.排序操作 //

model->setSort(0,Qt::AscendingOrder); //id属性，即第0列，升序排列
model->select();
model->setSort(0,Qt::DescendingOrder);
model->select();

5.删除行

// int curRow = ui->tableView->currentIndex().row();
//获取选中的行
//  model->removeRow(curRow);   //删除一行
//删除该行
QItemSelectionModel *selections = ui->tableView->selectionModel(); //返回当前的选择模式
QModelIndexList selected = selections->selectedIndexes();   //返回所有选定模型项目索引列表
foreach (QModelIndex index, selected)
{
int curRow=index.row();
model->removeRow(curRow);   //删除所有被选中的行
}
int ok = QMessageBox::warning(this,tr("删除当前行!"),tr("你确定"
"删除当前行吗？"),
QMessageBox::Yes,QMessageBox::No);
if(ok == QMessageBox::No)
{
model->revertAll(); //如果不删除，则撤销
}
else model->submitAll(); //否则提交，在数据库中删除该行

6.插入操作//插入行

int rowNum = model->rowCount(); //获得表的行数

int id = 10;

model->insertRow(rowNum); //添加一行

model->setData(model->index(rowNum,0),id); //给新行添加id属性值

//model->submitAll(); //可以直接提交

QSqlRelationalTableModel->Inherits QSqlTableModel->Inherits QSqlQueryModel->Inherits QAbstractTableModel->Inherits QAbstractItemModel->Inherits QObjec

第五：QSqlRelationalTableModel--该类为单张的数据库表提供了一个可编辑的数据模型，它支持外键，除此之外和QSqlTableModel没有什么不同

model->setRelation(2,QSqlRelation(“course”,”id”,”name”)); //设置外键

//将student表的第三个属性设为course表的id属性的外键，并将其显示为course表的name属性的值(course表在id上显示为name属性值)

如果用户更改课程属性，那么他只能在课程表中有的课程中进行选择，而不能随意填写课程。在Qt中的QSqlRelationalDelegate委托类就能实现这个功能

ui->tableView->setItemDelegate(new QSqlRelationalDelegate(ui->tableView));

QSqlRelationalDelegate类--提供委托delegate用来显示编辑QSqlRelationalTableModel类

QTableView *view = new QTableView;

view->setModel(model);

view->setItemDelegate(new QSqlRelationalDelegate(view));

QDataWidgetMapper类可以将数据库和控件(如QLineEdit)连接起来，使控件得到数据库的值(例子：editEmployees)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。