DELPHI操作数据库的问题(200分)

请问各位：
当我用DELPHI的TQUERY或TTABLE向数据库服务器插入一条数据时，DBGRID并不更新
或显示的数据总不爽（虽然实际数据库中已经存放了数据）。
我想请问各位如何在不关闭数据集的情况下实现数据刷新包括显示部分？
Refresh可不管用！
拜托了！

在添加40分,这可是我的全部积蓄，一定请各位帮忙！

用两个数据集
1。一个用来显示SELECT
2。一个用来做DELETE、INSERT、UPDATE操作

调用数据集的Close方法之后，再调用Open试试

当Delete,UpDate操作后,如果Select的数据集关闭再打开,就会First,需要从新定位，
这时候屏幕会出现轻微的闪烁，性能也受影响，显得很迟钝。另外那怕很简单的程序
也要写一堆Code,如何是好?

如果是从新定位时DBGRID出现闪烁， 你可以先把DBGRID的DATASOURCE属性设为NIL，等定位
完以后再赋上，这样可以去掉闪烁，而且可以提高性能！

如果你不是用sql语句去对数据库操作，而只是用query.delete,query.append,query.insert
query.edit去修改数据的话就不用去刷新了，自然也不会有上述问题了。

在表上建立主键
在程序中REFRESH

你可以先把DBGRID的DATASOURCE属性设为NIL也不是不可以，你想我这如此多得表、
来回折腾太麻烦了，有没有事半功倍的办法？

表中肯定有主键的，使用REFRESH还是报错！

我是菜鸟

我感觉要和你讨论一下程序设计的问题了

当Delete,UpDate操作后,如果Select的数据集关闭再打开,就会First,需要从新定位，
这时候屏幕会出现轻微的闪烁，性能也受影响，显得很迟钝。
----用LISTVIEW替换TREEVIEW
把表示层和数据层分开(这几乎成为我的一句口头禅了)
这样就要写更多的CODE了
下面就回答你的第二个问题.

另外那怕很简单的程序
也要写一堆Code,如何是好?

----不管程序有多简单写出优质代码才是最重要的
如果你这个程序的确很简单,但在系统中地位很重要
还是值得你下工夫的.

一个再简单的程序也应该有一个良好的结构和执行效率

以下是我写的一个很简单的软件的持久流化部分
程序里只用到两个表

{*******************************************************}
{ }
{ Resource Classes }
{ }
{ 1999,2000 NARI IS Corporation }
{ }
{*******************************************************}

unit ResClses;

interface

uses
Sysutils, Classes, ComCtrls, Db, ResCallDB, ResDBUtils;

type
TResIUDMode = (rmInsert, rmUpdate, rmDelete);
TResPasteMode = (rpmCut, rpmCopy);
TResSearchFlag = (rsfFind, rsfNotFind);

type
TResVirtualNode = class end;

type
TRes = class;
TResCls = class;
TResInst = class;

TRes = class(TObject)
private
FResID: Integer;
FResName: string;
FResCode: string;
FResNote: string;
FResDispIndex: Integer;
FResCallDB: TResCallDB;
public
constructor Create; overload; virtual;
destructor Destroy; override;
procedure LoadFromDataSet; virtual;
procedure Assign(Source: TRes); virtual;
procedure SelectByID(ID: Integer); virtual;
procedure DbInsert; virtual;
procedure DbUpdate; virtual;
procedure DbDelete; virtual;
procedure UpdateListItem(Item: TListItem); virtual;
function Clone: TRes; virtual;
function Duplicate: TRes; virtual;
property ResID: Integer read FResID write FResID;
property ResName: string read FResName write FResName;
property ResCode: string read FResCode write FResCode;
property ResNote: string read FResNote write FResNote;
property ResDispIndex: Integer read FResDispIndex write FResDispIndex;
property ResCallDB: TResCallDB read FResCallDB write FResCallDB;
end;

TResCls = class(TRes)
private
FResParID: Integer;
FResVRFlag: string;
FResSchema: string;
FResView: string;
public
constructor Create; override;
destructor Destroy; override;
procedure LoadFromDataSet; override;
procedure Assign(Source: TRes); override;
procedure SelectByID(ID: Integer); override;
procedure DbInsert; override;
procedure DbUpdate; override;
procedure DbDelete; override;
procedure UpdateListItem(Item: TListItem); override;
function Clone: TRes; override;
function Duplicate: TRes; override;
procedure CreateView;
procedure DropView;
property ResParID: Integer read FResParID write FResParID;
property ResVRFlag: string read FResVRFlag write FResVRFlag;
property ResSchema: string read FResSchema write FResSchema;
property ResView: string read FResView write FResView;
end;

TResInst = class(TRes)
private
FResClsID: Integer;
FResExtFlag: string;
FResValFlag: string;
public
constructor Create; override;
destructor Destroy; override;
procedure LoadFromDataSet; override;
procedure Assign(Source: TRes); override;
procedure SelectByID(ID: Integer); override;
procedure DbInsert; override;
procedure DbUpdate; override;
procedure DbDelete; override;
procedure UpdateListItem(Item: TListItem); override;
function Clone: TRes; override;
function Duplicate: TRes; override;
property ResClsID: Integer read FResClsID write FResClsID;
property ResExtFlag: string read FResExtFlag write FResExtFlag;
property ResValFlag: string read FResValFlag write FResValFlag;
end;

implementation

uses
ResUtils;

//------------------------------------------------------------------------------
// TRes
//------------------------------------------------------------------------------
constructor TRes.Create;
begin
inherited;
FResCallDB := TResDOACallDB.Create;
end;

destructor TRes.Destroy;
begin
FResCallDB.Free;
inherited;
end;

procedure TRes.LoadFromDataSet;
begin

end;

procedure TRes.Assign(Source: TRes);
begin
if Source is TRes then
begin
ResID := TRes(Source).ResID;
ResName := TRes(Source).ResName;
ResCode := TRes(Source).ResCode;
ResDispIndex := TRes(Source).ResDispIndex;
ResNote := TRes(Source).ResNote;
end;
end;

procedure TRes.SelectByID(ID: Integer);
begin

end;

procedure TRes.DbInsert;
begin

end;

procedure TRes.DbUpdate;
begin

end;

procedure TRes.DbDelete;
begin

end;

procedure TRes.UpdateListItem(Item: TListItem);
begin
with Item do
begin
Caption := ResName;
Data := Self;
SubItems.Clear;
end;
end;

function TRes.Clone: TRes;
begin
Result := nil;
end;

function TRes.Duplicate: TRes;
begin
Result := nil;
end;

//------------------------------------------------------------------------------
// TResCls
//------------------------------------------------------------------------------
constructor TResCls.Create;
begin
inherited;
end;

destructor TResCls.Destroy;
begin
inherited;
end;

procedure TResCls.LoadFromDataSet;
begin
inherited;
Assert(ResCallDB.DataSet.Active);
Assert(not ResCallDB.DataSet.Eof);
with ResCallDB.DataSet do
begin
ResID := FieldByName('RES_CLS_ID').AsInteger;
ResName := FieldByName('RES_CLS_NAME').AsString;
ResCode := FieldByName('RES_CLS_CODE').AsString;
ResNote := FieldByName('RES_CLS_NOTE').AsString;
ResDispIndex := FieldByName('RES_CLS_DISPINDEX').AsInteger;
ResParID := FieldByName('RES_CLS_PARID').AsInteger;
ResVRFlag := FieldByName('RES_CLS_VRFLAG').AsString;
ResSchema := FieldByName('RES_CLS_SCHEMA').AsString;
ResView := FieldByName('RES_CLS_VIEW').AsString;
end;
end;

procedure TResCls.Assign(Source: TRes);
begin
inherited;
if Source is TResCls then
begin
ResParID := TResCls(Source).ResParID;
ResVRFlag := TResCls(Source).ResVRFlag;
ResSchema := TResCls(Source).ResSchema;
ResView := TResCls(Source).ResView;
end;
end;

procedure TResCls.SelectByID(ID: Integer);
const
strSql = 'SELECT * FROM PMIS.COM_RES_CLS WHERE RES_CLS_ID = %D';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlOpen(Format(strSql, [ID]));
LoadFromDataSet;
SqlOpenEnd;
end;
end;

procedure TResCls.DbInsert;
const
strSql = 'INSERT INTO PMIS.COM_RES_CLS '
+ '(RES_CLS_ID,'
+ 'RES_CLS_NAME,'
+ 'RES_CLS_CODE,'
+ 'RES_CLS_NOTE,'
+ 'RES_CLS_DISPINDEX,'
+ 'RES_CLS_PARID,'
+ 'RES_CLS_VRFLAG,'
+ 'RES_CLS_SCHEMA,'
+ 'RES_CLS_VIEW) '
+ 'VALUES (%D, ''%S'', ''%S'', ''%S'', %D, %D, ''%S'', ''%S'', ''%S'')';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResID, ResName, ResCode, ResNote, ResDispIndex,
ResParID, ResVRFlag, ResSchema, ResView]));
SqlExecEnd;
end;
end;

procedure TResCls.DbUpdate;
const
strSql = 'UPDATE PMIS.COM_RES_CLS '
+ 'SET '
+ 'RES_CLS_NAME = ''%S'','
+ 'RES_CLS_CODE = ''%S'','
+ 'RES_CLS_NOTE = ''%S'','
+ 'RES_CLS_DISPINDEX = %D,'
+ 'RES_CLS_PARID = %D,'
+ 'RES_CLS_SCHEMA = ''%S'','
+ 'RES_CLS_VIEW = ''%S'''
+ 'WHERE RES_CLS_ID = %D';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResName, ResCode, ResNote, ResDispIndex, ResParID,
ResSchema, ResView, ResID]));
SqlExecEnd;
end;
end;

procedure TResCls.DbDelete;
const
strSql = 'DELETE FROM PMIS.COM_RES_CLS WHERE RES_CLS_ID = %D';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResID]));
SqlExecEnd;
end;
end;

procedure TResCls.CreateView;
const
strSql = 'CREATE VIEW %S.%S '
+ 'AS '
+ 'SELECT RES_INST_ID AS ID,'
+ ' RES_INST_NAME AS NAME,'
+ ' RES_INST_DISPINDEX AS DISPINDEX '
+ 'FROM PMIS.COM_RES_INST '
+ 'WHERE RES_CLS_ID = '
+ '(SELECT RES_CLS_ID FROM PMIS.COM_RES_CLS '
+ 'WHERE RES_CLS_CODE = ''%S'') '
+ 'AND RES_INST_VALFLAG = ''T''';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResSchema, ResView, ResCode]));
SqlExecEnd;
end;
end;

procedure TResCls.DropView;
const
strSql = 'DROP VIEW %S.%S';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResSchema, ResView]));
SqlExecEnd;
end;
end;

procedure TResCls.UpdateListItem(Item: TListItem);
begin
inherited;
with Item.SubItems do
begin
Add(ResCode);
Add(InterpretResVRFlag(ResVRFlag));
Add(ResSchema);
Add(ResView);
Add(ResNote);
end;
end;

function TResCls.Clone: TRes;
var
rsResCls: TResCls;
begin
rsResCls := TResCls.Create;
with rsResCls do
begin
ResID := TResCls(Self).ResID;
ResName := TResCls(Self).ResName;
ResCode := TResCls(Self).ResCode;
ResDispIndex := TResCls(Self).ResDispIndex;
ResNote := TResCls(Self).ResNote;
ResParID := TResCls(Self).ResParID;
ResVRFlag := TResCls(Self).ResVRFlag;
ResSchema := TResCls(Self).ResSchema;
ResView := TResCls(Self).ResView;
end;
Result := rsResCls;
end;

function TResCls.Duplicate: TRes;
var
rsResCls: TResCls;
begin
rsResCls := TResCls.Create;
with rsResCls do
begin
ResID := GetNextRecID('PMIS.COM_RES_CLS_ID_SEQ');
ResName := TResCls(Self).ResName;
ResCode := TResCls(Self).ResCode;
ResDispIndex := ResID;
ResNote := TResCls(Self).ResNote;
ResParID := TResCls(Self).ResParID;
ResVRFlag := TResCls(Self).ResVRFlag;
ResSchema := TResCls(Self).ResSchema;
ResView := TResCls(Self).ResView;
end;
Result := rsResCls;
end;

//------------------------------------------------------------------------------
// TResInst
//------------------------------------------------------------------------------
constructor TResInst.Create;
begin
inherited;
end;

destructor TResInst.Destroy;
begin
inherited;
end;

procedure TResInst.LoadFromDataSet;
begin
inherited;
Assert(ResCallDB.DataSet.Active);
Assert(not ResCallDB.DataSet.Eof);
with ResCallDB.DataSet do
begin
ResID := FieldByName('RES_INST_ID').AsInteger;
ResName := FieldByName('RES_INST_NAME').AsString;
ResCode := FieldByName('RES_INST_CODE').AsString;
ResDispIndex := FieldByName('RES_INST_DISPINDEX').AsInteger;
ResNote := FieldByName('RES_INST_NOTE').AsString;
ResValFlag := FieldByName('RES_INST_VALFLAG').AsString;
ResExtFlag := FieldByName('RES_INST_EXTFLAG').AsString;
ResClsID := FieldByName('RES_CLS_ID').AsInteger;
end;
end;

procedure TResInst.Assign(Source: TRes);
begin
inherited;
if Source is TResInst then
begin
ResValFlag := TResInst(Source).ResValFlag;
ResExtFlag := TResInst(Source).ResExtFlag;
ResClsID := TResInst(Source).ResClsID;
end;
end;

procedure TResInst.SelectByID(ID: Integer);
const
strSql = 'SELECT * FROM PMIS.COM_RES_INST WHERE RES_INST_ID = %D';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlOpen(Format(strSql, [ID]));
LoadFromDataSet;
SqlOpenEnd;
end;
end;

procedure TResInst.DbInsert;
const
strSql = 'INSERT INTO PMIS.COM_RES_INST '
+ '(RES_INST_ID,'
+ 'RES_INST_NAME,'
+ 'RES_INST_CODE,'
+ 'RES_INST_DISPINDEX,'
+ 'RES_INST_NOTE,'
+ 'RES_INST_VALFLAG,'
+ 'RES_INST_EXTFLAG,'
+ 'RES_CLS_ID)'
+ 'VALUES (%D, ''%S'', ''%S'', %D, ''%S'', ''%S'', ''%S'', %D)';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResID, ResName, ResCode, ResDispIndex, ResNote,
ResValFlag, ResExtFlag, ResClsID]));
SqlExecEnd;
end;
end;

procedure TResInst.DbUpdate;
const
strSql = 'UPDATE PMIS.COM_RES_INST '
+ 'SET '
+ 'RES_INST_NAME = ''%S'','
+ 'RES_INST_CODE = ''%S'','
+ 'RES_INST_DISPINDEX = %D,'
+ 'RES_INST_NOTE = ''%S'','
+ 'RES_INST_VALFLAG = ''%S'','
+ 'RES_INST_EXTFLAG = ''%S'','
+ 'RES_CLS_ID = %D '
+ 'WHERE RES_INST_ID = %D';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResName, ResCode, ResDispIndex, ResNote, ResValFlag,
ResExtFlag, ResClsID, ResID]));
SqlExecEnd;
end;
end;

procedure TResInst.DbDelete;
const
strSql = 'DELETE FROM PMIS.COM_RES_INST WHERE RES_INST_ID = %D';
begin
inherited;
Assert(ResCallDB <> nil);
with ResCallDB do
begin
SqlExec(Format(strSql, [ResID]));
SqlExecEnd;
end;
end;

procedure TResInst.UpdateListItem(Item: TListItem);
begin
inherited;
with Item.SubItems do
begin
Add(ResCode);
Add(InterpretResValFlag(ResValFlag));
Add(InterpretResExtFlag(ResExtFlag));
Add(ResNote);
end;
end;

function TResInst.Clone: TRes;
var
rsResInst: TResInst;
begin
rsResInst := TResInst.Create;
with rsResInst do
begin
ResID := TResInst(Self).ResID;
ResName := TResInst(Self).ResName;
ResCode := TResInst(Self).ResCode;
ResDispIndex := TResInst(Self).ResDispIndex;
ResNote := TResInst(Self).ResNote;
ResValFlag := TResInst(Self).ResValFlag;
ResExtFlag := TResInst(Self).ResExtFlag;
ResClsID := TResInst(Self).ResClsID;
end;
Result := rsResInst;
end;

function TResInst.Duplicate: TRes;
var
rsResInst: TResInst;
begin
rsResInst := TResInst.Create;
with rsResInst do
begin
ResID := GetNextRecID('PMIS.COM_RES_INST_ID_SEQ');
ResName := TResInst(Self).ResName;
ResCode := TResInst(Self).ResCode;
ResDispIndex := ResID;
ResNote := TResInst(Self).ResNote;
ResValFlag := TResInst(Self).ResValFlag;
ResExtFlag := TResInst(Self).ResExtFlag;
ResClsID := TResInst(Self).ResClsID;
end;
Result := rsResInst;
end;


end.


--------------------------------------------
添加时
1.在LISTVIEW上加一条记录
2.在数据库里物理插入一条记录

删除时
1.删掉LISTVIEW里的那条记录
2.删除数据里对应记录

修改时,注意方法
procedure UpdateListItem(Item: TListItem);

傻瓜照相机是好,专业人员不用,
专业人员就是用了,
也要求不高的时候玩玩的.

不就是不让dbgrid闪烁吗
dbgrid.disablecontrol;
.............
query1.close;
query1.open;
dbgrid.enablecontrol;

我很感谢笑傲江湖！
但是在你的程序中对一张表都如此大动干戈，如果考虑输入的格式问题那
工作量是太大了。我觉得Delphi之所以功能强大、使用简单是因为它的的
组织结构上的一些特点给所想既所得的感觉而且可延伸性。我认为解决这个
问题应从DELPHI的特点出发，多想想Delphi如何实现它现在是如何完成现在
的功能的。在它的基础上继续完善。

但是在你的程序中对一张表都如此大动干戈，如果考虑输入的格式问题那
工作量是太大了。我觉得Delphi之所以功能强大、使用简单是因为它的的
组织结构上的一些特点给所想既所得的感觉而且可延伸性。我认为解决这个
问题应从DELPHI的特点出发，多想想Delphi如何实现它现在是如何完成现在
的功能的。在它的基础上继续完善。

----DELPHI功能强大是事实,使用简单?
为什么说使用简单,你指哪方面.
----组织结构上的一些特点给所想既所得的感觉而且可延伸性。
是什么意思.
----多想想Delphi如何实现它现在是如何完成现在
的功能的--->VCL的源码是人写出来的.

----我还没有贴一个代码近5000行的PERSISTENTS UNIT
某一天你进行平台级软件开发的话, 你会想起来我给你说过的这番话的.

学DELPHI也罢, VC++也罢, JAVA也罢,
学的都是面向对象.

另外我上面贴的那个例子有一个版本,就是用DELPHI的控件
关联了几把,代码非常短,但不是我要的效果.

你大概没仔细看看我对关系数据库---对象语言映射所
构造的类, 已及它们输出的方法.

这个问题到此为止罢

TO 笑傲江湖：
我觉得你对我的话有一些误解！
------- 组织结构上的一些特点（所想既所得的，而且可延伸性）。
“所想既所得的”,“可延伸性”是一个什么样的境界，还是靠自己的体会。
---- VCL的源码是人写出来的.
怎么写出来的，你完全体会了它的设计思路了吗？
你充分利用了吗？
我现在还不知道什么是平台开发，能否举个例子？

catchedupdates

哈哈

多人接受答案了。