新手和老手在增加记录、保存记录、删除记录、查询记录的写法有什么区别？用ADODATASET。有位老总说一眼就看出来了。

Question

新手和老手在增加记录、保存记录、删除记录、查询记录的写法有什么区别？用ADODATASET。有位老总说一眼就看出来了。

Answer 1

老手都把这封装好了, sql语句自动生成.

Answer 2

可能老手用insert,update这些吧，可能新手用append,edit这些哟

Answer 3

老手和新手的区别应该在记录查询上吧，老手能够很熟练的使用SQL语言，写出一些高效的sql代码，老手能熟练的对多个表进行操作，sql代码效率比较高吧，在DDl方面，我认为新手和老手应该差不多的

Answer 4

新手或许是:
  DataSet.Append;Post;Delete;
老手或许是:
  SQL.Add(....);
  SQL.Exec....
高手或许是:
  DataSet.Append;Post;Delete;何必拘泥于招式?

Answer 5

我刚学的时候，下载了几个demo,那增删改可真是五花八门呀。

Answer 6

我觉得主要还是在出错的处理方面.
新手一般都不会注意有可能出错的地方,比如对有可能一个空表进行Delete操作;
而老手都会对这些可能存在的错误进行处理,确保软件运行的时候不会出错.

Answer 7

偶觉得把业务逻辑放在服务器端的 一般复杂的查询都写成存储过程 简单的添加删除操作都用SQL实现 能提高效率

Answer 8

没区别的
个人习惯SQL不见得就效率高，一样要解析为基本方法处理的
SQL局限性比较大，有不少东西SQL是不好处理或处理不到的

Answer 9

方法不一定要规定，
谁敢说用query执行sql的效率会比用dataset自带的append等方法高呢？
主要还是看使用场合
用自带方法简单，用sql执行灵活

Answer 10

定义几个函数，把要修改或者插入的信息作为参数输入，还要有容错处理。
例如一个插入记录的函数：
procdure  InsertData（InsertTable:TADOTable;FieldName:String;Value:String）；
begin
   if InsertTable.State in [dsInsert] then
      InsertTable.FiledByName(FiledName).value:=Value;
   Try
      InsertTable.Post;
   Except 
   begin
     Showmesssage('你在插入记录提交时出错，请检查后重新运行！');
     Exit;
   end;
随手写出来的，没有在delphi上检查运行，就算是伪代码吧！
end;

Answer 11

建议使用sql语句进行更新，delphi使用post，edit等更新的时候问题比较多！

Answer 12

delphi刚开始学习，不知道老手和新手有什么区别。
以前学习java的时候能感觉出来，当时觉得老手新手都是手，不过后来自己看了别人的代码之后感觉的确不错。
注释，异常处理，结构性，条理性，封装（如何封装也是一种很高的技巧），调试......下面有一段java的代码，个人认为还是不错的（当然，注释少了一点）。
package cn.com.hitsec.car;/**
 * <p>Title: </p>
 * <p>Description: </p>
 * <p>Copyright: Copyright (c) 2003</p>
 * <p>Company: </p>
 * @author not attributable
 * @version 1.0
 */import beans.common.db.sqlserver.DBBean;
import java.sql.ResultSet;
import java.util.Vector;
import cn.com.hitsec.doc.Tools;
import beans.security.main.*;public class CarDA {  private DBBean db = null;
  private boolean conflag = false;
  private String errorMessage;  private int carId;
  private String carNum;
  private String carXh;
  private String driver;
  private String state;
  private String createDate;
  private String driverName;
  private String creator;
  private String memo;
  private String carN;
  private String carC;
  private String carF;
  private String carX;
  private String carT;  public CarDA() {
    this.db = new DBBean();
    this.carId = 0;
    this.carNum = null;
    this.carXh = null;
    this.driver = null;
    this.state = null;
    this.driverName = null;
    this.createDate = null;
    this.creator = null;
    this.memo = "";
  }
  public int getCarId() {
    return carId;
  }
  public void setCarId(int carId) {
    this.carId = carId;
  }  public String getCarNum() {
    return carNum;
  }
  public void setCarNum(String carNum) {
    this.carNum = carNum;
  }  public String getCarN() {
    return carN;
  }
  public void setCarN(String carN) {
    this.carN = carN;
  }  public String getCarF() {
    return carF;
  }
  public void setCarF(String carF) {
    this.carF = carF;
  }  public String getCarX() {
    return carX;
  }
  public void setCarX(String carX) {
    this.carX = carX;
  }  public String getCarT() {
    return carT;
  }
  public void setCarT(String carT) {
    this.carT = carT;
  }  public String getCarC() {
    return carC;
  }
  public void setCarC(String carC) {
    this.carC = carC;
  }
  public String getCarXh() {
    return carXh;
  }
  public void setCarXh(String carXh) {
    this.carXh = carXh;
  }
  public String getDriver() {
    return driver;
  }
  public void setDriver(String driver) {
    this.driver = driver;
  }
  public String getState() {
    return state;
  }
  public void setState(String state) {
    this.state = state;
  }
  public String getCreateDate() {
    return createDate;
  }
  public void setCreateDate(String createDate) {
    this.createDate = createDate;
  }
  public String getDriverName() {
    return driverName;
  }
  public void setDriverName(String driverName) {
    this.driverName = driverName;
  }
  public String getCreator() {
    return creator;
  }
  public void setCreator(String creator) {
    this.creator = creator;
  }
  public String getMemo() {
    return memo;
  }
  public void setMemo(String memo) {
    this.memo = memo;
  }
  /**
   * 删除一条数据
   * 输入：主键ID
   * 输出：成功：true 失败 false
   */
  public boolean delete(String primaryKey){
    boolean flag = false;
    CarRecordDA di=new CarRecordDA();
    try{
      flag = db.execute("DELETE FROM car WHERE carId ="+primaryKey);
      flag = di.delete(primaryKey);
    }
    catch(Exception ex){
      flag = false;
      Tools.printMes(ex.getMessage());
    }
    finally{
      Free();
      Tools.printMes("delete--DELETE FROM car WHERE carId="+primaryKey);
    }
    return flag;
  }  /**
   * 修改一条数据
   * 输入：CarDA CarDA
   * 输出：修改成功 ture 失败false
   */
  public boolean update(){
    boolean flag = false;
    String sqltext = "";
    try{
      sqltext = "UPDATE Car SET ";
      sqltext += "CarNum="+Tools.ConStr(this.getCarNum())+",";
      sqltext += "CarXh="+Tools.ConStr(this.getCarXh())+",";
      sqltext += "Driver="+Tools.ConStr(this.getDriver())+",";
      sqltext += "State="+Tools.ConStr(this.getState())+",";
      sqltext += "createDate="+Tools.ConStr(Tools.CurrentDateTime())+",";
      sqltext += "creator="+Tools.ConStr(this.getCreator())+",";
      sqltext += "carc="+Tools.ConStr(this.getCarC())+",";
      sqltext += "carf="+Tools.ConStr(this.getCarF())+",";
      sqltext += "carx="+Tools.ConStr(this.getCarX())+",";
      sqltext += "carn="+Tools.ConStr(this.getCarN())+",";
      sqltext += "cart="+Tools.ConStr(this.getCarT())+",";      sqltext += "memo="+Tools.ConStr(this.getMemo());
      sqltext += " where CarId="+this.getCarId();
      flag =  db.execute(sqltext);
    }
    catch(Exception ex){
      flag = false;
      Tools.printMes(ex.getMessage());
    }
    finally{
      Free();
      Tools.printMes("update--"+sqltext);
    }
    return flag;
  }  /**
   * 修改一条数据
   * 输入：CarDA CarDA
   * 输出：修改成功 ture 失败false
   */
  public boolean updateState(){
    boolean flag = false;
    String sqltext = "";
    try{
      sqltext = "UPDATE Car SET ";
      sqltext += "State="+Tools.ConStr(this.getState())+",";
      sqltext += "createDate="+Tools.ConStr(Tools.CurrentDateTime())+",";
      sqltext += "creator="+Tools.ConStr(this.getCreator());
      sqltext += " where CarId="+this.getCarId();
      flag =  db.execute(sqltext);
    }
    catch(Exception ex){
      flag = false;
      Tools.printMes(ex.getMessage());
    }
    finally{
      Free();
      Tools.printMes("update--"+sqltext);
    }
    return flag;
  }  /**
   * 插入一条数据
   * 输入：CarDA CarDA
   * 输出：修改成功 ture 失败false
   */
  public int inSert(){
    int id = 0;
    String sqltext = "";
    try{
      sqltext = "INSERT INTO Car(CarNum,CarXh,Driver,State,createDate,creator,carc,carf,carx,carn,cart,memo) VALUES( ";
      sqltext += Tools.ConStr(this.getCarNum())+",";
      sqltext += Tools.ConStr(this.getCarXh())+",";
      sqltext += Tools.ConStr(this.getDriver())+",";
      sqltext += Tools.ConStr("no")+",";
      sqltext += Tools.ConStr(Tools.CurrentDateTime())+",";
      sqltext += Tools.ConStr(this.getCreator())+",";      sqltext += Tools.ConStr(this.getCarC())+",";
      sqltext += Tools.ConStr(this.getCarF())+",";
      sqltext += Tools.ConStr(this.getCarX())+",";
      sqltext += Tools.ConStr(this.getCarN())+",";
      sqltext += Tools.ConStr(this.getCarT())+",";      sqltext += Tools.ConStr(this.getMemo());
      sqltext += ")";
      if( db.execute(sqltext) ){
        ResultSet rs = db.getResults("SELECT MAX(CarID) AS id FROM Car");
        rs.next();
        id = rs.getInt("id");
      }
      sqltext = "insert into carrecord (carid,cartype,memo) values(" + id +
          ",'维护记录','')";
      if (db.execute(sqltext)) {
        sqltext = "insert into carrecord (carid,cartype,memo) values(" + id +
            ",'保险记录','')";
        if (db.execute(sqltext)) {
          sqltext = "insert into carrecord (carid,cartype,memo) values(" + id +
              ",'费用记录','')";
          db.execute(sqltext);
        }
      }
    }
    catch(Exception ex){
      Tools.printMes(ex.getMessage());
    }
    finally{
      Free();
      Tools.printMes("inSert--"+sqltext);
    }
    return id;
  }

Answer 13

/**
   * 根据主键查查找一条记录
   * 输入：主键ID
   * 输出：
   * 返回类型：CarDA
   */
  public CarDA findByPrimaryKey(String primaryKey){
    CarDA di = null;
    ResultSet rs = null;
    try{
      rs = db.getResults("SELECT * FROM Car WHERE CarID="+primaryKey);
      rs.next();
      di = new CarDA();
      di.setCarId(rs.getInt("CarID"));
      di.setCarNum(rs.getString("CarNum").trim());
      di.setCarXh(rs.getString("CarXh").trim());
      di.setDriver(rs.getString("Driver").trim());      di.setCarC(rs.getString("carc").trim());
      di.setCarF(rs.getString("carf").trim());
      di.setCarX(rs.getString("carx").trim());
      di.setCarN(rs.getString("carn").trim());
      di.setCarT(rs.getString("cart").trim());      User oneUser = new User();
      oneUser.setUserId(di.getDriver());
      Vector vfind = (Vector) oneUser.Query("and");
      if (vfind != null && vfind.size() > 0)
        di.setDriverName( ( (User) vfind.elementAt(0)).getName().trim());
      else
        di.setDriverName(" ");
      di.setState(rs.getString("State").trim());
      di.setCreateDate(rs.getString("createDate").trim());
      di.setCreator(rs.getString("Creator").trim());
      di.setMemo(rs.getString("Memo").trim());
    }
    catch(Exception ex){
      di = null;
      Tools.printMes("findByPrimaryKey-Error:"+ex.getMessage());
    }
    finally{
      Free();
      Tools.printMes("findByPrimaryKey--SELECT * FROM Car WHERE CarID="+primaryKey);
    }
    return di;
  }  /**
   * 根据状态查找车辆列表信息
   * 输入：state
   * 输出：
   * 返回类型：Vector
   */
  public Vector findByState(String state){
    CarDA di = null;
    ResultSet rs = null;
    Vector resList = new Vector();
    try{
      rs = db.getResults("SELECT * FROM Car WHERE State="+state);
      while(rs.next()){
        di = new CarDA();
        di.setCarId(rs.getInt("CarID"));
        di.setCarNum(rs.getString("CarNum").trim());
        di.setCarXh(rs.getString("CarXh").trim());
        di.setDriver(rs.getString("Driver").trim());        di.setCarC(rs.getString("carc").trim());
        di.setCarF(rs.getString("carf").trim());
        di.setCarX(rs.getString("carx").trim());
        di.setCarN(rs.getString("carn").trim());
        di.setCarT(rs.getString("cart").trim());        User oneUser = new User();
        oneUser.setUserId(di.getDriver());
        Vector vfind = (Vector) oneUser.Query("and");
        if (vfind != null && vfind.size() > 0)
          di.setDriverName( ( (User) vfind.elementAt(0)).getName().trim());
        else
          di.setDriverName(" ");
        di.setState(rs.getString("State").trim());
        di.setCreateDate(rs.getString("createDate").trim());
        di.setCreator(rs.getString("Creator").trim());
        di.setMemo(rs.getString("Memo").trim());
        resList.add(di);
      }
    }
    catch(Exception ex){
      di = null;
      Tools.printMes("findByPrimaryKey-Error:"+ex.getMessage());
    }
    finally{
      Free();
      Tools.printMes("findByState--SELECT * FROM Car WHERE State="+state);
    }
    return resList;
  }  /**
   * 查找全部车辆信息
   * 输入：
   * 输出：
   * 返回类型：Vector
   */
  public Vector findALL(){
    CarDA di = null;
    ResultSet rs = null;
    Vector resList = new Vector();
    try{
      rs = db.getResults("SELECT * FROM Car ");
      while(rs.next()){
        di = new CarDA();
        di.setCarId(rs.getInt("CarID"));
        di.setCarNum(rs.getString("CarNum").trim());
        di.setCarXh(rs.getString("CarXh").trim());
        di.setDriver(rs.getString("Driver").trim());        di.setCarC(rs.getString("carc").trim());
        di.setCarF(rs.getString("carf").trim());
        di.setCarX(rs.getString("carx").trim());
        di.setCarN(rs.getString("carn").trim());
        di.setCarT(rs.getString("cart").trim());        User oneUser = new User();
        oneUser.setUserId(di.getDriver());
        Vector vfind = (Vector) oneUser.Query("and");
        if (vfind != null && vfind.size() > 0)
          di.setDriverName( ( (User) vfind.elementAt(0)).getName().trim());
        else
          di.setDriverName(" ");
        di.setState(rs.getString("State").trim());
        di.setCreateDate(rs.getString("createDate").trim());
        di.setCreator(rs.getString("Creator").trim());
        di.setMemo(rs.getString("Memo").trim());
        resList.add(di);
      }
    }
    catch(Exception ex){
      resList = null;
      Tools.printMes("findALL-Error:"+ex.getMessage());
    }
    finally{
      Free();
      Tools.printMes("findALL--SELECT * FROM Car ");
    }
    return resList;
  }  /**
     * 根据状态查找车辆列表信息
     * 输入：state
     * 输出：
     * 返回类型：Vector
     */
    public Vector Query(String Logic){
      Vector resList = new Vector();
      ResultSet rs = null;
      CarDA di = null;
      String inLogic = "";
      String strWhere = "where ";
      String sql = "";
      if (Logic.equals("or")) {
        inLogic = "or";
      }
      else {
        inLogic = "and";
      }
      if (! (this.carNum == null)) {
        strWhere += "carNum= '" + this.carNum + "' " + inLogic + " ";
      }
      if (! (this.carXh == null)) {
        strWhere += "carXh= '" + this.carXh + "' " + inLogic + " ";
      }
      if (! (this.driver == null)) {
        strWhere += "driver= '" + this.driver + "' " + inLogic + " ";
      }
      if (! (this.state == null)) {
        strWhere += "state= '" + this.state + "' " + inLogic + " ";
      }
      try {
        strWhere = strWhere.substring(0, strWhere.lastIndexOf(inLogic));
      }
      catch (Exception ex) {
        strWhere = "";
      }
      try {
        sql = "SELECT * FROM Car " + strWhere;
        rs = db.getResults(sql);
        while (rs.next()) {
          di = new CarDA();
          di.setCarId(rs.getInt("CarID"));
          di.setCarNum(rs.getString("CarNum").trim());
          di.setCarXh(rs.getString("CarXh").trim());
          di.setDriver(rs.getString("Driver").trim());          di.setCarC(rs.getString("carc").trim());
          di.setCarF(rs.getString("carf").trim());
          di.setCarX(rs.getString("carx").trim());
          di.setCarN(rs.getString("carn").trim());
          di.setCarT(rs.getString("cart").trim());          User oneUser = new User();
          oneUser.setUserId(di.getDriver());
          Vector vfind = (Vector) oneUser.Query("and");
          if (vfind != null && vfind.size() > 0)
            di.setDriverName( ( (User) vfind.elementAt(0)).getName().trim());
          else
            di.setDriverName(" ");
          di.setState(rs.getString("State").trim());
          di.setCreateDate(rs.getString("createDate").trim());
          di.setCreator(rs.getString("Creator").trim());
          resList.add(di);
        }
      }
      catch (Exception ex) {
        di = null;
        Tools.printMes("Query-Error:" + ex.getMessage());
      }
      finally {
        Free();
        Tools.printMes("Query--",sql);
      }
      return resList;
    }  /**
   *关闭数据库连接
   */
  private void Free(){
    try{
      db.getConn(true);
      db.closeAll();
      }catch(Exception ex){}
  }
}

Answer 14

无休止的复制粘贴
－－－－－－－－－－－
同感，我也这样写，一下午曾粘贴过2000多行：）
不过这样写逻辑上清晰，以后修改时方便。
理论上这些重复工作可以用O/R Mapping解决，只是Delphi下不知发展的如何了，也没有用过。

Answer 15

我开始也是写  fieldbyname...........后来都用ipcontrol和dbedit之类数据敏感控件.
今天大家都没有用dbedit吗?

Answer 16

的确是无休止的复制    粘贴不过如果我需要对付的是200个表
我想我一定会这样做
至少条理上很清楚
也很容易修改调试
当然
工作效率也上去了注释：当然，这个的注释并不是最好，不过也凑合先用了吧，差不多可以自动生成doc了。
异常处理：这个也不是最好，但至少做得相对全面。
结构性：这个只是最基本的操作什么的，熟得不能再熟了，也许简单也是一种好吧。
条理性：不需要说了吧？个人觉得很有条理性。
封装（如何封装也是一种很高的技巧）：其实不完全，因为不可能都贴出来。上面的DBbean,Tools，还有上面没有的，我不没有办法都弄出来，但个人觉得老手和新手在这上面的确有很多的差异。
调试：Tools.printMes("Query--",sql);我想应该很容易看出来问题最大可能出在哪个地方了吧？并且还有一个类，里面专门放了调试信息的开关等。其他的还有，至少我在用的时候感觉是给后面的人（维护，学习等）很大的方便，效率高，不容易产生思维上的混乱，可扩展性好等。呵呵，不好意思，偶是新人，说错话了大家勿怪并指出。

Answer 17

其实我也有一个问题：就是老手们总是告诉新手们少碰数据库控制组件和第三方控件。
个人觉得第三方控件因为熟悉度不够，不容易把握，的确少用为好。
但delphi自带的数据库控制组件（data controls）为什么也应该少用呢？
害得每次都用listbox代替dblistbox，感觉累而且效率不高。

Answer 18

晕死
上面是java的代码，呵呵
我在最前面说了
delphi我是新手
不好意思啊

Answer 19

应该没有什么明显的区别的！
不敢被称为老手，现在基本不使用数据感知组件或者Delphi封装后的数据访问组件，一般来说常用原生ADO来获取记录集（速度比较快），用普通的文本显示组件来显示数据（虽然有些麻烦，但是控制起来比较自由，稳定性要好）。然后把常用的比较通用的方法（翻页显示、数据校验等等）放在一个模块中，在工程中统一引用后，开发速度要快不少……

Answer 20

上面的Java代码是将对象的属性映射到数据库的表结构上（如果我没理解错的话），程序调用时，直接对对象操作，将对数据库的操作封装起来了，这样你在修改了数据库的结构或业务逻辑后，只须将这个类的实现修改一下即可，如果你将SQL语句写的到处都是，那修改起来就要吐血了（俺的第一个程序就是写的这麽乱，以至于现在都不敢随便改东西）。我以前用过一次数据感应控件，因为时间要求紧，我就想用它来提高效率，可是用起来并不自由，想自己在程序中给它赋个值，它死活不让（或许我用的不熟）。结果还是将所有数据感应控件全换成普通控件了事，以后再也不碰数据感应控件了。用的不多，不敢乱讲，感觉用数据感应控件就是不自由，不符合面向对象，尤其在多层结构中，客户端根本看不到数据库，你怎么感知呢？

Answer 21

呵呵
还是eastliangliang分析的厉害

Answer 22

高手是这样操作记录的！
http://developer.ccidnet.com/pub/disp/Article?columnID=322&articleID=28999&pageNO=1http://developer.ccidnet.com/pub/disp/Article?columnID=294&articleID=28940&pageNO=1

Answer 23

可能老手都是把对数据库的操作封装了，不使用数据感知组件有助于界面和代码的分离，有时间看看刘艺的delphi面象对象编程思想，把对数据库的操作和用户界面分离有助于程序的健壮性和可维护性，在实际工作中运用后，感触颇深。