转：ios Sqlite数据库增删改查基本操作

　　研究了几天的数据库，终于把它给搞出来了。Sqlite是ios上最常用的数据库之一，大家还是有必要了解一下的。这是仿照网上的一个例子做的，有些部分写的不好，我稍作了修改，以讲解为主，主要让大家能够明白如何修改，明白原理，达到举一反三的目的。

先来看看效果图

　　先来看看数据库方法类，将各个操作都封装在一个类里面，达到代码重用的目的，这是程序员都应该努力去实现的目标，这样在下一次用到同样的方法和类的时候，就可以直接使用封装好的类，可以节约大量的时间。

先来看看.h文件

#import <Foundation/Foundation.h>
#import <sqlite3.h>

#define kFilename  @"testdb.db"
@class sqlTestList;
@interface sqlService : NSObject {
    sqlite3 *_database;

}

@property (nonatomic) sqlite3 *_database;
-(BOOL) createTestList:(sqlite3 *)db;//创建数据库
-(BOOL) insertTestList:(sqlTestList *)insertList;//插入数据
-(BOOL) updateTestList:(sqlTestList *)updateList;//更新数据
-(NSMutableArray*)getTestList;//获取全部数据
- (BOOL) deleteTestList:(sqlTestList *)deletList;//删除数据：
- (NSMutableArray*)searchTestList:(NSString*)searchString;//查询数据库，searchID为要查询数据的ID，返回数据为查询到的数据
@end

@interface sqlTestList : NSObject//重新定义了一个类，专门用于存储数据
{
    int sqlID;
    NSString *sqlText;
    NSString *sqlname;
}

@property (nonatomic) int sqlID;
@property (nonatomic, retain) NSString *sqlText;
@property (nonatomic, retain) NSString *sqlname;

@end

再来看看.m文件

//
//  sqlService.m
//  SQLite3Test
//
//  Created by fengxiao on 11-11-28.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//

#import "sqlService.h"

@implementation sqlService

@synthesize _database;

- (id)init
{
    return self;
}

- (void)dealloc
{
    [super dealloc];
}

//获取document目录并返回数据库目录
- (NSString *)dataFilePath{

    NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
    NSString *documentsDirectory = [paths objectAtIndex:0];
    NSLog(@"=======%@",documentsDirectory);
    return [documentsDirectory stringByAppendingPathComponent:@"data.db"];//这里很神奇，可以定义成任何类型的文件，也可以不定义成.db文件，任何格式都行，定义成.sb文件都行，达到了很好的数据隐秘性

}

//创建，打开数据库
- (BOOL)openDB {

    //获取数据库路径
    NSString *path = [self dataFilePath];
    //文件管理器
    NSFileManager *fileManager = [NSFileManager defaultManager];
    //判断数据库是否存在
    BOOL find = [fileManager fileExistsAtPath:path];

    //如果数据库存在，则用sqlite3_open直接打开（不要担心，如果数据库不存在sqlite3_open会自动创建）
    if (find) {

        NSLog(@"Database file have already existed.");

        //打开数据库，这里的[path UTF8String]是将NSString转换为C字符串，因为SQLite3是采用可移植的C(而不是
        //Objective-C)编写的，它不知道什么是NSString.
        if(sqlite3_open([path UTF8String], &_database) != SQLITE_OK) {

            //如果打开数据库失败则关闭数据库
            sqlite3_close(self._database);
            NSLog(@"Error: open database file.");
            return NO;
        }

        //创建一个新表
        [self createTestList:self._database];

        return YES;
    }
    //如果发现数据库不存在则利用sqlite3_open创建数据库（上面已经提到过），与上面相同，路径要转换为C字符串
    if(sqlite3_open([path UTF8String], &_database) == SQLITE_OK) {

        //创建一个新表
        [self createTestList:self._database];
        return YES;
    } else {
        //如果创建并打开数据库失败则关闭数据库
        sqlite3_close(self._database);
        NSLog(@"Error: open database file.");
        return NO;
    }
    return NO;
}

//创建表
- (BOOL) createTestList:(sqlite3*)db {

    //这句是大家熟悉的SQL语句
    char *sql = "create table if not exists testTable(ID INTEGER PRIMARY KEY AUTOINCREMENT, testID int,testValue text,testName text)";// testID是列名，int 是数据类型，testValue是列名，text是数据类型，是字符串类型

    sqlite3_stmt *statement;
    //sqlite3_prepare_v2 接口把一条SQL语句解析到statement结构里去. 使用该接口访问数据库是当前比较好的的一种方法
    NSInteger sqlReturn = sqlite3_prepare_v2(_database, sql, -1, &statement, nil);
    //第一个参数跟前面一样，是个sqlite3 * 类型变量，
    //第二个参数是一个 sql 语句。
    //第三个参数我写的是-1，这个参数含义是前面 sql 语句的长度。如果小于0，sqlite会自动计算它的长度（把sql语句当成以\0结尾的字符串）。
    //第四个参数是sqlite3_stmt 的指针的指针。解析以后的sql语句就放在这个结构里。
    //第五个参数是错误信息提示，一般不用,为nil就可以了。
    //如果这个函数执行成功（返回值是 SQLITE_OK 且 statement 不为NULL ），那么下面就可以开始插入二进制数据。

    //如果SQL语句解析出错的话程序返回
    if(sqlReturn != SQLITE_OK) {
        NSLog(@"Error: failed to prepare statement:create test table");
        return NO;
    }

    //执行SQL语句
    int success = sqlite3_step(statement);
    //释放sqlite3_stmt
    sqlite3_finalize(statement);

    //执行SQL语句失败
    if ( success != SQLITE_DONE) {
        NSLog(@"Error: failed to dehydrate:create table test");
        return NO;
    }
    NSLog(@"Create table 'testTable' successed.");
    return YES;
}

//插入数据
-(BOOL) insertTestList:(sqlTestList *)insertList {

    //先判断数据库是否打开
    if ([self openDB]) {

        sqlite3_stmt *statement;

        //这个 sql 语句特别之处在于 values 里面有个? 号。在sqlite3_prepare函数里，?号表示一个未定的值，它的值等下才插入。
        static char *sql = "INSERT INTO testTable(testID, testValue,testName) VALUES(?, ?, ?)";

        int success2 = sqlite3_prepare_v2(_database, sql, -1, &statement, NULL);
        if (success2 != SQLITE_OK) {
            NSLog(@"Error: failed to insert:testTable");
            sqlite3_close(_database);
            return NO;
        }

        //这里的数字1，2，3代表上面的第几个问号，这里将三个值绑定到三个绑定变量
        sqlite3_bind_int(statement, 1, insertList.sqlID);
        sqlite3_bind_text(statement, 2, [insertList.sqlText UTF8String], -1, SQLITE_TRANSIENT);
        sqlite3_bind_text(statement, 3, [insertList.sqlname UTF8String], -1, SQLITE_TRANSIENT);

        //执行插入语句
        success2 = sqlite3_step(statement);
        //释放statement
        sqlite3_finalize(statement);

        //如果插入失败
        if (success2 == SQLITE_ERROR) {
            NSLog(@"Error: failed to insert into the database with message.");
            //关闭数据库
            sqlite3_close(_database);
            return NO;
        }
        //关闭数据库
        sqlite3_close(_database);
        return YES;
    }
    return NO;
}

//获取数据
- (NSMutableArray*)getTestList{

    NSMutableArray *array = [NSMutableArray arrayWithCapacity:10];
    //判断数据库是否打开
    if ([self openDB]) {

        sqlite3_stmt *statement = nil;
        //sql语句
        char *sql = "SELECT testID, testValue ,testName FROM testTable";//从testTable这个表中获取 testID, testValue ,testName，若获取全部的话可以用*代替testID, testValue ,testName。

        if (sqlite3_prepare_v2(_database, sql, -1, &statement, NULL) != SQLITE_OK) {
            NSLog(@"Error: failed to prepare statement with message:get testValue.");
            return NO;
        }
        else {
            //查询结果集中一条一条的遍历所有的记录，这里的数字对应的是列值,注意这里的列值，跟上面sqlite3_bind_text绑定的列值不一样！一定要分开，不然会crash，只有这一处的列号不同，注意！
            while (sqlite3_step(statement) == SQLITE_ROW) {
                sqlTestList* sqlList = [[sqlTestList alloc] init] ;
                sqlList.sqlID    = sqlite3_column_int(statement,0);
                char* strText   = (char*)sqlite3_column_text(statement, 1);
                sqlList.sqlText = [NSString stringWithUTF8String:strText];
                char *strName = (char*)sqlite3_column_text(statement, 2);
                sqlList.sqlname = [NSString stringWithUTF8String:strName];
                [array addObject:sqlList];
                [sqlList release];
            }
        }
        sqlite3_finalize(statement);
        sqlite3_close(_database);
    }

    return [array retain];//定义了自动释放的NSArray，这样不是个好办法，会造成内存泄露，建议大家定义局部的数组，再赋给属性变量。
}

//更新数据
-(BOOL) updateTestList:(sqlTestList *)updateList{

    if ([self openDB]) {
        sqlite3_stmt *statement;//这相当一个容器，放转化OK的sql语句
        //组织SQL语句
        char *sql = "update testTable set testValue = ? and testName = ? WHERE testID = ?";

        //将SQL语句放入sqlite3_stmt中
        int success = sqlite3_prepare_v2(_database, sql, -1, &statement, NULL);
        if (success != SQLITE_OK) {
            NSLog(@"Error: failed to update:testTable");
            sqlite3_close(_database);
            return NO;
        }

        //这里的数字1，2，3代表第几个问号。这里只有1个问号，这是一个相对比较简单的数据库操作，真正的项目中会远远比这个复杂
        //绑定text类型的数据库数据
        sqlite3_bind_text(statement, 3, [updateList.sqlname UTF8String], -1, SQLITE_TRANSIENT);
        sqlite3_bind_text(statement, 2, [updateList.sqlText UTF8String], -1, SQLITE_TRANSIENT);
        sqlite3_bind_int(statement, 1, updateList.sqlID);

        //执行SQL语句。这里是更新数据库
        success = sqlite3_step(statement);
        //释放statement
        sqlite3_finalize(statement);

        //如果执行失败
        if (success == SQLITE_ERROR) {
            NSLog(@"Error: failed to update the database with message.");
            //关闭数据库
            sqlite3_close(_database);
            return NO;
        }
        //执行成功后依然要关闭数据库
        sqlite3_close(_database);
        return YES;
    }
    return NO;
}
//删除数据
- (BOOL) deleteTestList:(sqlTestList *)deletList{
    if ([self openDB]) {

        sqlite3_stmt *statement;
        //组织SQL语句
        static char *sql = "delete from testTable  where testID = ? and testValue = ? and testName = ?";
        //将SQL语句放入sqlite3_stmt中
        int success = sqlite3_prepare_v2(_database, sql, -1, &statement, NULL);
        if (success != SQLITE_OK) {
            NSLog(@"Error: failed to delete:testTable");
            sqlite3_close(_database);
            return NO;
        }

        //这里的数字1，2，3代表第几个问号。这里只有1个问号，这是一个相对比较简单的数据库操作，真正的项目中会远远比这个复杂
        sqlite3_bind_int(statement, 1, deletList.sqlID);
        sqlite3_bind_text(statement, 2, [deletList.sqlText UTF8String], -1, SQLITE_TRANSIENT);
        sqlite3_bind_text(statement, 3, [deletList.sqlname UTF8String], -1, SQLITE_TRANSIENT);
        //执行SQL语句。这里是更新数据库
        success = sqlite3_step(statement);
        //释放statement
        sqlite3_finalize(statement);

        //如果执行失败
        if (success == SQLITE_ERROR) {
            NSLog(@"Error: failed to delete the database with message.");
            //关闭数据库
            sqlite3_close(_database);
            return NO;
        }
        //执行成功后依然要关闭数据库
        sqlite3_close(_database);
        return YES;
    }
    return NO;

}
//查询数据
- (NSMutableArray*)searchTestList:(NSString*)searchString{

    NSMutableArray *array = [NSMutableArray arrayWithCapacity:10];
    //判断数据库是否打开
    if ([self openDB]) {

        sqlite3_stmt *statement = nil;
        //sql语句
        NSString *querySQL = [NSString stringWithFormat:@"SELECT * from testTable where testName like \"%@\"",searchString];
        const char *sql = [querySQL UTF8String];
//        char *sql = "SELECT * FROM testTable WHERE testName like ?";//这里用like代替=可以执行模糊查找，原来是"SELECT * FROM testTable WHERE testName = ?"
        if (sqlite3_prepare_v2(_database, sql, -1, &statement, NULL) != SQLITE_OK) {
            NSLog(@"Error: failed to prepare statement with message:search testValue.");
            return NO;
        } else {
            sqlTestList *searchList = [[sqlTestList alloc]init];
//            sqlite3_bind_int(statement, 1, searchID);
            sqlite3_bind_text(statement, 3, [searchString UTF8String], -1, SQLITE_TRANSIENT);
            //查询结果集中一条一条的遍历所有的记录，这里的数字对应的是列值。
            while (sqlite3_step(statement) == SQLITE_ROW) {
                sqlTestList* sqlList = [[sqlTestList alloc] init] ;
                sqlList.sqlID   = sqlite3_column_int(statement,1);
                char* strText   = (char*)sqlite3_column_text(statement, 2);
                sqlList.sqlText = [NSString stringWithUTF8String:strText];
                char *strName = (char*)sqlite3_column_text(statement, 3);
                sqlList.sqlname = [NSString stringWithUTF8String:strName];
                [array addObject:sqlList];
                [sqlList release];
            }
            [searchList release];
        }
        sqlite3_finalize(statement);
        sqlite3_close(_database);
    }

    return [array retain];
}

@end

@implementation sqlTestList//刚才.h文件里定义的类在这实现

@synthesize sqlID;
@synthesize sqlText;
@synthesize sqlname;
-(id) init
{
    sqlID = 0;
    sqlText = @"";
    sqlname = @"";
    return self;
};
-(void) dealloc
{
    if ((sqlText != nil) && (sqlname != nil)) {
        [sqlText release];
        [sqlname release];
    }

    [super dealloc];
}

@end

这就是封装好的类，可以重用哦！

下面是添加数据页面

aaarticlea/png;base64,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" alt="" />

这也是一个类，来看.h文件

#import <UIKit/UIKit.h>
#import "sqlService.h"

@interface operateSqlViewController : UIViewController {

    UITextField *idValue;
    UITextField *textValue;
    UITextField *textName;
    int oprateType;//区分数据插入与更新
    sqlTestList *sqlValue;
}

@property (nonatomic, retain) IBOutlet UITextField *idValue;
@property (nonatomic, retain) IBOutlet UITextField *textValue;
@property (nonatomic, retain) IBOutlet UITextField *textName;
@property (nonatomic, retain) sqlTestList *sqlValue;
@property (nonatomic) int oprateType;

@end

再来看看.m文件

#import "operateSqlViewController.h"

@implementation operateSqlViewController
@synthesize idValue;
@synthesize textValue;
@synthesize oprateType;
@synthesize sqlValue;
@synthesize textName;
- (void)didReceiveMemoryWarning {
    // Releases the view if it doesn't have a superview.
    [super didReceiveMemoryWarning];

    // Release any cached data, images, etc. that aren't in use.
}

- (void)viewDidLoad{

    UIBarButtonItem *backButton = [[UIBarButtonItem alloc]
                                   initWithTitle:@"返回"
                                   style:UIBarButtonItemStyleBordered
                                   target:self
                                   action:@selector(dismiss:)];

    UIBarButtonItem *saveButton = [[UIBarButtonItem alloc]
                                   initWithTitle:@"保存"
                                   style:UIBarButtonItemStyleBordered
                                   target:self
                                   action:@selector(saveValue:)];
    [[self navigationItem] setLeftBarButtonItem:backButton];
    [[self navigationItem] setRightBarButtonItem:saveButton];

    [backButton release];
    [saveButton release];

    if (oprateType == 0) {
        [self.navigationItem setTitle:@"数据插入"];
    }
    else if(oprateType == 1){
        [self.navigationItem setTitle:@"数据更新"];
        idValue.text = [NSString stringWithFormat:@"%d", sqlValue.sqlID];
        textValue.text = sqlValue.sqlText;
        textName.text = sqlValue.sqlname;
    }
}

- (void)viewDidUnload {
    idValue = nil;
    textValue = nil;
    textName = nil;
    sqlValue = nil;
    [super viewDidUnload];
    // Release any retained subviews of the main view.
    // e.g. self.myOutlet = nil;
}

- (void)dealloc {
    [idValue release];
    [textValue release];
    [sqlValue release];
    [textName release];
    [super dealloc];
}

- (void)dismiss:(id)sender{
    [[self parentViewController] dismissModalViewControllerAnimated:YES];
}
- (void)saveValue:(id)sender{

    if (idValue.text.length == 0) {
            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                            message:@"请输入ID"
                                                           delegate:self
                                                  cancelButtonTitle:@"好"
                                                  otherButtonTitles:nil];
            [alert show];
            [alert release];
        return;
    }
    if (textValue.text.length == 0) {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                        message:@"请输入电话"
                                                       delegate:self
                                              cancelButtonTitle:@"好"
                                              otherButtonTitles:nil];
        [alert show];
        [alert release];
        return;
    }
    if (textName.text.length == 0) {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                        message:@"请输入姓名"
                                                       delegate:self
                                              cancelButtonTitle:@"好"
                                              otherButtonTitles:nil];
        [alert show];
        [alert release];
        return;
    }

    //初始化数据库
    sqlService *sqlSer = [[sqlService alloc] init];

    //数据库插入
    if (oprateType == 0) {

        sqlTestList *sqlInsert = [[sqlTestList alloc]init];
        sqlInsert.sqlID = [idValue.text intValue];
        sqlInsert.sqlText = textValue.text;
        sqlInsert.sqlname = textName.text;

        //调用封装好的数据库插入函数
        if ([sqlSer insertTestList:sqlInsert]) {
            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                            message:@"插入数据成功"
                                                           delegate:self
                                                  cancelButtonTitle:@"好"
                                                  otherButtonTitles:nil];
            [alert show];
            [alert release];
        }
        else {
            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                            message:@"插入数据失败"
                                                           delegate:self
                                                  cancelButtonTitle:@"好"
                                                  otherButtonTitles:nil];
            [alert show];
            [alert release];

        }
        [sqlInsert release];

    }
    //数据库更新
    if(oprateType == 1){

        sqlTestList *newValue = [[sqlTestList alloc]init];
        newValue.sqlID = [idValue.text intValue];
        newValue.sqlText = textValue.text;
        newValue.sqlname = textName.text;

        //调用封装好的更新数据库函数
        if ([sqlSer updateTestList:newValue]) {
            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                            message:@"更新数据成功"
                                                           delegate:self
                                                  cancelButtonTitle:@"好"
                                                  otherButtonTitles:nil];
            [alert show];
            [alert release];
        }
        else {
            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                            message:@"更新数据失败"
                                                           delegate:self
                                                  cancelButtonTitle:@"好"
                                                  otherButtonTitles:nil];
            [alert show];
            [alert release];

        }

        [newValue release];
    }

}

@end

代码写的有些啰嗦，不过不难容易看懂，不多解释了，要在xib文件中添加3个UITextField和ULabel，要记得连线。

在主界面的.h文件

#import <UIKit/UIKit.h>
#import "sqlService.h"
@interface SQLite3TestViewController : UIViewController<UITableViewDelegate,UITableViewDataSource> {

    UITableView *utableView;
    NSArray *listData;
    UISearchBar *searchBar;//搜索栏

}

@property (nonatomic, retain) IBOutlet UITableView *utableView;
@property (nonatomic, retain) IBOutlet UISearchBar *searchBar;
@property (nonatomic, retain) NSArray *listData;

- (IBAction)insertValue;
- (IBAction)updateValue;
- (IBAction)getAllValue;
- (IBAction)deleteValue;
- (IBAction)searchValue;

@end

.m文件

//
//  SQLite3TestViewController.m
//  SQLite3Test
//
//  Created by fengxiao on 11-11-28.
//  Copyright 2011 __MyCompanyName__. All rights reserved.
//

#import "SQLite3TestViewController.h"
#import "operateSqlViewController.h"

@implementation SQLite3TestViewController
@synthesize utableView;
@synthesize listData;
@synthesize searchBar;

- (void)viewDidLoad{
    sqlService *sqlSer = [[sqlService alloc] init];
    listData = [sqlSer getTestList];//先初始化那个专门用于存数据的类，才调用类获取数据的方法
}

- (void)viewDidAppear:(BOOL)animated{//在这里写是为了等待时间缩短一点，数据如果很多的，在这里写可以让数据提前加载
    sqlService *sqlSer = [[sqlService alloc] init];
    listData = [sqlSer getTestList];
    [sqlSer release];
    [utableView reloadData];
}

- (void)didReceiveMemoryWarning {
    // Releases the view if it doesn't have a superview.
    [super didReceiveMemoryWarning];

    // Release any cached data, images, etc that aren't in use.
}

- (void)viewDidUnload {
    utableView = nil;
    listData = nil;
    searchBar = nil;
    [super viewDidUnload];
    // Release any retained subviews of the main view.
    // e.g. self.myOutlet = nil;
}

- (void)dealloc {
    [utableView release];
    [listData release];
    [searchBar release];
    [super dealloc];
}

- (IBAction)insertValue{

    [searchBar resignFirstResponder];//触发这个insertValue方法时隐藏键盘
    operateSqlViewController *operateController = [[operateSqlViewController alloc] init ];
    UINavigationController *theNavController = [[UINavigationController alloc]
                                                initWithRootViewController:operateController];//这里如果不初始化一个UINavigationController类的对象来存放operateSqlViewController类的UIViewController，就不会有最上面的导航栏了。
    operateController.oprateType = 0;//optrateType为0时为数据插入
    [operateController release];
    theNavController.navigationBar.tintColor = [UIColor blackColor];
    [self presentModalViewController:theNavController animated:YES];
    [theNavController release];
}

- (IBAction)updateValue{

    [searchBar resignFirstResponder];
    NSIndexPath *indexPath = [utableView  indexPathForSelectedRow];
    if (indexPath == nil) {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                        message:@"请选择要更新的项"
                                                       delegate:self
                                              cancelButtonTitle:@"好"
                                              otherButtonTitles:nil];
        [alert show];
        [alert release];
        return;
    }

    NSUInteger row = [indexPath row];
    sqlTestList *sqlList = [[sqlTestList alloc]init];
    sqlList = [listData objectAtIndex:(row - 1)];//在这里面获取点击的行，因为table的第一行没显示数据，所以这里要减1。

    operateSqlViewController *operateController = [[operateSqlViewController alloc] init ];
    UINavigationController *theNavController = [[UINavigationController alloc]
                                                initWithRootViewController:operateController];
    operateController.oprateType = 1;//optrateType为1时为数据更新
    operateController.sqlValue = sqlList;
    theNavController.navigationBar.tintColor = [UIColor blackColor];
    [self presentModalViewController:theNavController animated:YES];
    [sqlList release];
    [operateController release];
    [theNavController release];
}

- (IBAction)getAllValue{

    [searchBar resignFirstResponder];

    sqlService *sqlSer = [[sqlService alloc] init];
    listData = [sqlSer getTestList];
    [utableView reloadData];
    [sqlSer release];

}
- (IBAction)deleteValue{

    [searchBar resignFirstResponder];

    NSIndexPath *indexPath = [utableView  indexPathForSelectedRow];

    if (indexPath == nil) {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                        message:@"请选择要删除的项"
                                                       delegate:self
                                              cancelButtonTitle:@"好"
                                              otherButtonTitles:nil];
        [alert show];
        [alert release];
        return;
    }

    NSUInteger row = [indexPath row];
    sqlTestList *sqlList = [[sqlTestList alloc]init];
    sqlList = [listData objectAtIndex:(row - 1)];

    sqlService *sqlSer = [[sqlService alloc] init];

     if ([sqlSer deleteTestList:sqlList]) {
         UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                         message:@"删除数据成功"
                                                        delegate:self
                                               cancelButtonTitle:@"好"
                                               otherButtonTitles:nil];
         [alert show];
         [alert release];

         //删除成功后重新获取数据更新列表
         listData = [sqlSer getTestList];
         [utableView reloadData];

     }
    else {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                        message:@"删除数据失败"
                                                       delegate:self
                                              cancelButtonTitle:@"好"
                                              otherButtonTitles:nil];
        [alert show];
        [alert release];
        return;
    }

    [sqlList release];
    [sqlSer release];
}
- (IBAction)searchValue{

    if ([searchBar.text isEqualToString:@""]) {
        UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                        message:@"请输入要查询数据的ID"
                                                       delegate:self
                                              cancelButtonTitle:@"好"
                                              otherButtonTitles:nil];
        [alert show];
        [alert release];
        return;
    }
    else {
//        int idNum = [searchBar.text intValue];
        NSString *str = searchBar.text;
        sqlService *sqlSer = [[sqlService alloc] init];
        listData = [sqlSer searchTestList:str];

        if ([listData  count] == 0) {
            UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"提示"
                                                            message:@"sorry,未查询到数据，请查看name是否有误"
                                                           delegate:self
                                                  cancelButtonTitle:@"好"
                                                  otherButtonTitles:nil];
            [alert show];
            [alert release];
            return;
        }
        [searchBar resignFirstResponder];
        [utableView reloadData];
        [sqlSer release];

    }
}

#pragma mark -
#pragma mark Table View Data Source Methods
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    // Return the number of rows in the section.
    return [listData count] + 1;//从第二行开始，第一行不显示数据
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{

    NSString *CustomIdentifier =  [NSString stringWithFormat:@"cell%d",indexPath.row];
    //cell不重用
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CustomIdentifier];
    if (indexPath.row == 0)
    cell.selectionStyle = UITableViewCellSelectionStyleNone;
    if ( cell == nil ) {
        cell = [[[UITableViewCell alloc] initWithStyle:UITableViewCellStyleValue1
                                         reuseIdentifier:CustomIdentifier] autorelease];
        cell.backgroundColor = [UIColor clearColor];
            }
    if (indexPath.row > 0)
    {
        NSUInteger row = [indexPath row];
        sqlTestList *sqlList = [[sqlTestList alloc] init] ;

        if (listData != nil)
        sqlList = [listData objectAtIndex: (row - 1)];//读取数据的时候也要减一行，从第二行开始

        UILabel *nameLabel = [[UILabel alloc]initWithFrame:CGRectMake(0+40, 10, 70, 30)];
        UILabel *IDLabel = [[UILabel alloc]initWithFrame:CGRectMake(90+40, 10, 70, 30)];
        UILabel *valueLabel = [[UILabel alloc]initWithFrame:CGRectMake(180+40, 10, 70, 30)];
        nameLabel.text = sqlList.sqlname;
        IDLabel.text = sqlList.sqlText;
        valueLabel.text = [NSString stringWithFormat:@"%d",sqlList.sqlID];
        [cell.contentView addSubview:nameLabel];
        [cell.contentView addSubview:IDLabel];
        [cell.contentView addSubview:valueLabel];
        [nameLabel release];
        [IDLabel release];
        [valueLabel release];
    }
    else
        {
        for (int i = 0; i < 3; i ++) {
            UILabel *label = [[UILabel alloc]initWithFrame:CGRectMake(90 * i + 40, 10, 70 , 30)];
            NSArray *array = [NSArray arrayWithObjects:@"姓名",@"ID",@"电话", nil];
            label.text = [array objectAtIndex:i];
            label.backgroundColor = [UIColor clearColor];
            [cell.contentView addSubview:label];
            [label release];
        }
    }
    return cell;
}

- (NSIndexPath*)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    [searchBar resignFirstResponder];
    if (indexPath.row == 0) {
        return nil;//让第一行不能点击
    }
    else
        return indexPath;
}

@end

好了，这就是全部了，希望大家尽量封装自己写的类，现在写得多，以后会很轻松。

有什么问题请给我留言。

转自：http://www.cnblogs.com/xiaobaizhu/archive/2012/12/07/2808170.html