方法1： 用SET PASSWORD命令

　　mysql -u root

　　mysql> SET PASSWORD FOR 'root'@'localhost' = PASSWORD('newpass');

方法2：用mysqladmin

　　mysqladmin -u root password "newpass"

　　如果root已经设置过密码，采用如下方法

　　mysqladmin -u root password oldpass "newpass"

方法3： 用UPDATE直接编辑user表

　　mysql -u root

　　mysql> use mysql;

　　mysql> UPDATE user SET Password = PASSWORD('newpass') WHERE user = 'root';

　　mysql> FLUSH PRIVILEGES;

在丢失root密码的时候，可以这样

　　mysqld_safe --skip-grant-tables&

　　mysql -u root mysql

　　mysql> UPDATE user SET password=PASSWORD("new password") WHERE user='root';

　　mysql> FLUSH PRIVILEGES;

引言

　　数据库的设计范式是数据库设计所需要满足的规范，满足这些规范的数据库是简洁的、结构明晰的，同时，不会发生插入（insert）、删除（delete）和更新（update）操作异常。反之则是乱七八糟，不仅给数据库的编程人员制造麻烦，而且面目可憎，可能存储了大量不需要的冗余信息。

　　设计范式是不是很难懂呢？非也，大学教材上给我们一堆数学公式我们当然看不懂，也记不住。所以我们很多人就根本不按照范式来设计数据库。

　　实质上，设计范式用很形象、很简洁的话语就能说清楚，道明白。本文将对范式进行通俗地说明，并以笔者曾经设计的一个简单论坛的数据库为例来讲解怎样将这些范式应用于实际工程。

　　范式说明

　　第一范式（1NF）：数据库表中的字段都是单一属性的，不可再分。这个单一属性由基本类型构成，包括整型、实数、字符型、逻辑型、日期型等。

　　例如，如下的数据库表是符合第一范式的：

　　很显然，在当前的任何关系数据库管理系统（DBMS）中，傻瓜也不可能做出不符合第一范式的数据库，因为这些DBMS不允许你把数据库表的一列再分成二列或多列。因此，你想在现有的DBMS中设计出不符合第一范式的数据库都是不可能的。

　　第二范式（2NF）：数据库表中不存在非关键字段对任一候选关键字段的部分函数依赖（部分函数依赖指的是存在组合关键字中的某些字段决定非关键字段的情况），也即所有非关键字段都完全依赖于任意一组候选关键字。

　假设仓库管理关系表为StorehouseManage(仓库ID, 存储物品ID, 管理员ID, 数量)，且有一个管理员只在一个仓库工作；一个仓库可以存储多种物品。这个数据库表中存在如下决定关系：

　　(仓库ID, 存储物品ID) →(管理员ID, 数量)

　　(管理员ID, 存储物品ID) → (仓库ID, 数量)

　　所以，(仓库ID, 存储物品ID)和(管理员ID, 存储物品ID)都是StorehouseManage的候选关键字，表中的唯一非关键字段为数量，它是符合第三范式的。但是，由于存在如下决定关系：

　　(仓库ID) → (管理员ID)

　　(管理员ID) → (仓库ID)

　　即存在关键字段决定关键字段的情况，所以其不符合BCNF范式。它会出现如下异常情况：

　　(1) 删除异常：

　　当仓库被清空后，所有"存储物品ID"和"数量"信息被删除的同时，"仓库ID"和"管理员ID"信息也被删除了。

　　(2) 插入异常：

　　当仓库没有存储任何物品时，无法给仓库分配管理员。

　　(3) 更新异常：

　　如果仓库换了管理员，则表中所有行的管理员ID都要修改。

　　把仓库管理关系表分解为二个关系表：

　　仓库管理：StorehouseManage(仓库ID, 管理员ID)；

　　仓库：Storehouse(仓库ID, 存储物品ID, 数量)。

　　这样的数据库表是符合BCNF范式的，消除了删除异常、插入异常和更新异常。

范式应用

　　我们来逐步搞定一个论坛的数据库，有如下信息：

　　（1） 用户：用户名，email，主页，电话，联系地址

　　（2） 帖子：发帖标题，发帖内容，回复标题，回复内容

　　第一次我们将数据库设计为仅仅存在表：
　　

注意：
    当内存表中的数据大于max_heap_table_size设定的容量大小时，mysql会转换超出的数据存储到磁盘上，因此这是性能就大打折扣了，所以我们还需要根据我们的实际情况调整max_heap_table_size，例如在.cnf文件中[mysqld]的下面加入：
        max_heap_table_size = 2048M
    另外在建表语句中还可以通过MAX_ROWS来控制表的记录数。

内存表使用哈希散列索引把数据保存在内存中，因此具有极快的速度，适合缓存中小型数据库，但是使用上受到一些限制，以下是蓝草使用的一些感受。

1、heap对所有用户的连接是可见的，这使得它非常适合做缓存。

2、仅适合使用的场合。heap不允许使用xxxTEXT和xxxBLOB数据类型；只允许使用=和<=>操作符来搜索记录（不允许<、>、<=或>=）；不支持auto_increment；只允许对非空数据列进行索引（not null）。
注：操作符 “<=>” 说明：NULL-safe equal.这个操作符和“=”操作符执行相同的比较操作，不过在两个操作码均为NULL时，其所得值为1而不为NULL，而当一个操作码为NULL时，其所得值为0而不为NULL。

3、一旦服务器重启，所有heap表数据丢失，但是heap表结构仍然存在，因为heap表结构是存放在实际数据库路径下的，不会自动删除。重启之后，heap将被清空，这时候对heap的查询结果都是空的。

4、如果heap是复制的某数据表，则复制之后所有主键、索引、自增等格式将不复存在，需要重新添加主键和索引，如果需要的话。

5、对于重启造成的数据丢失，有以下的解决办法：
　a、在任何查询之前，执行一次简单的查询，判断heap表是否存在数据，如果不存在，则把数据重新写入，或者DROP表重新复制某张表。这需要多做一次查询。不过可以写成include文件，在需要用该heap表的页面随时调用，比较方便。
　b、对于需要该heap表的页面，在该页面第一次且仅在第一次查询该表时，对数据集结果进行判断，如果结果为空，则需要重新写入数据。这样可以节省一次查询。
　c、更好的办法是在mysql每次重新启动时自动写入数据到heap，但是需要配置服务器，过程比较复杂，通用性受到限制。

6、一些预期可能用到的sql语句

//如果表存在，则删除
DROP TABLE IF EXISTS `abc`;
//复制整张表xyz为heap表abc（包含所有数据）
CREATE TABLE `abc` type=heap select * from `xyz`;
//添加主键id
ALTER TABLE `abc` ADD PRIMARY KEY (`id`);
//添加索引username
ALTER TABLE `abc` ADD INDEX `abc` (`username`);
出自蓝草空间

/*连接Sqlite数据库，参数：dbname->数据库名字*/
function Open($dbname) {
if(!($this->link = @sqlite_open($dbname))) {
$this->halt('Can not Open to Sqlite');
}
}

/*执行sql语句，返回对应的结果标识*/
function Query($sql) {
$this->querynum++;
if($query = @sqlite_query($this->link, $sql)) {
return $query;
} else {
$this->halt('Sqlite Query Error', $sql);
}
}

/*执行Insert Into语句，并返回最后的insert操作所产生的自动增长的id*/
function Insert($table, $iarr) {
$value = $this->InsertSql($iarr);
$this->Query('INSERT INTO "' . $table . '" ' . $value);
return sqlite_last_insert_rowid($this->link);
}

/*执行Update语句，并返回最后的update操作所影响的行数*/
function Update($table, $uarr, $condition = '') {
$value = $this->UpdateSql($uarr);
if ($condition) {
$condition = ' WHERE ' . $condition;
}
$this->Query('UPDATE "' . $table . '"' . ' SET ' . $value . $condition);
return sqlite_changes($this->link);
}

/*执行Delete语句，并返回最后的Delete操作所影响的行数*/
function Delete($table, $condition = '') {
if ($condition) {
$condition = ' WHERE ' . $condition;
}
$this->Query('DELETE "' . $table . '"' . $condition);
return sqlite_changes($this->link);
}

/*将字符转为可以安全保存的sqlite值，比如a'a转为a''a*/
/*
function EnCode($str) {
if (strpos($str, "\0") === false) {
if (strpos($str, '\'') === false) {
return $str;
} else {
return str_replace('\'', '\'\'', $str);
}
} else {
$str = str_replace("\0", '', $str);
if (strpos($str, '\'') === false) {
return $str;
} else {
return str_replace('\'', '\'\'', $str);
}
}
}
*/
function EnCode($str) {
return sqlite_escape_string($str);
}

/*将可以安全保存的sqlite值转为正常的值，比如a''a转为a'a*/
function DeCode($str) {
if (strpos($str, '\'\'') === false) {
return $str;
} else {
return str_replace('\'\'', '\'', $str);
}
}

/*将对应的列和值生成对应的insert语句，如：array('id' => 1, 'name' => 'name')返回("id", "name") VALUES (1, 'name')*/
function InsertSql($iarr) {
if (is_array($iarr)) {
$fstr = '';
$vstr = '';
foreach ($iarr as $key => $val) {
$fstr .= '"' . $key . '", ';
$vstr .= '\'' . $val . '\', ';
}
if ($fstr) {
$fstr = '(' . substr($fstr, 0, -2) . ')';
$vstr = '(' . substr($vstr, 0, -2) . ')';
return $fstr . ' VALUES ' . $vstr;
} else {
return '';
}
} else {
return '';
}
}

/*将对应的列和值生成对应的insert语句，如：array('id' => 1, 'name' => 'name')返回"id" = 1, "name" = 'name'*/
function UpdateSql($uarr) {
if (is_array($uarr)) {
$ustr = '';
foreach ($uarr as $key => $val) {
$ustr .= '"' . $key . '" = \'' . $val . '\', ';
}
if ($ustr) {
return substr($ustr, 0, -2);
} else {
return '';
}
} else {
return '';
}
}

/*返回对应的查询标识的结果的一行*/
function GetRow($query, $result_type = SQLITE_ASSOC) {
return sqlite_fetch_array($query, $result_type);
}

/*清空查询结果所占用的内存资源*/
function Clear($query) {
$query = null;
return true;
}

/*关闭数据库*/
function Close() {
return sqlite_close($this->link);
}

function halt($message = '', $sql = '') {
$ei = sqlite_last_error($this->link);
$message .= '<br />Sqlite Error: ' . $ei . ', ' . sqlite_error_string($ei);
if ($sql) {
$sql = '<br />sql:' . $sql;
}
exit('DataBase Error.<br />Message: ' . $message . $sql);
}
}

struct olt_info
{
    int olt_index;
    int onu_on_line;
    int ui_port1;
    int ui_port2;
    int ui_port3;
    int ui_port4;
};

int my_callback(void * olt_temp, int argc, char * value[], char * name[])
{
    int i;
    struct olt_info * pdata = NULL;

    pdata = (struct olt_info *)olt_temp;
   
    puts("Here below is the code line:\n");
    for (i = 0; i < argc; i++)
    {
        printf("%s == %s\n", name[i], value[i]);
    }
    puts("Code line over.\n");
   
    pdata->olt_index = (int)atoi(value[0]);
    pdata->onu_on_line = (int)atoi(value[1]);
    pdata->ui_port1 = (int)atoi(value[2]);
    pdata->ui_port2 = (int)atoi(value[3]);
    pdata->ui_port3 = (int)atoi(value[4]);
    pdata->ui_port4 = (int)atoi(value[5]);
   
    return 0;
}

int main(int argc, char * argv[])
{
    sqlite3 * olt_db = NULL;
    int rc = 0;
    int i;
    char * err_msg = NULL;
    char temp_msg[150];
    struct olt_info * olt_temp= (struct olt_info *)malloc(sizeof(struct olt_info));   
   
    rc = sqlite3_open("olt.db", &olt_db);
    if (rc)
    {
        fprintf(stderr, "Open database error, %s\n", sqlite3_errmsg(olt_db));
        exit(1);
    }
    else
    {
        fprintf(stdout, "Open database OK.\n");
    }

    rc = sqlite3_exec(olt_db, "create table olt_tbl(olt_index integer primary key autoincrement, onu_on_line smallint, ui_port1 smallint, ui_port2 smallint, ui_port3 smallint, ui_port4 smallint);", NULL, NULL, &err_msg);

    if (rc != SQLITE_OK)
    {
        fprintf(stderr, "Create table error, %s\n", err_msg);
        exit(1);
    }
    else
    {
        fprintf(stdout, "Create table OK.\n");
    }

    for (i = 0; i < 6; i++)
    {
        sprintf(temp_msg, "insert into olt_tbl(onu_on_line, ui_port1, ui_port2, ui_port3, ui_port4) values(%d, %d, %d, %d, %d)", i * 16, i, i, i, i);
        //rc = sqlite3_exec(olt_db, "insert into olt_tbl(onu_on_line, ui_port1, ui_port2, ui_port3, ui_port4) values(32, 1, 1, 1, 1);", NULL, NULL, &err_msg);
        rc = sqlite3_exec(olt_db, temp_msg, NULL, NULL, &err_msg);
    }

    if (rc != SQLITE_OK)
    {
        fprintf(stderr, "Insert items failure, %s\n", err_msg);
    }
    else
    {
        fprintf(stdout, "Insert items OK.\n");
    }

    rc = sqlite3_exec(olt_db, "select * from olt_tbl where olt_index==4;", my_callback, olt_temp, &err_msg);
    if (rc != SQLITE_OK)
    {
        fprintf(stderr, "Selete from olt_tbl failure, %s\n", err_msg);
        exit(1);
    }
    else
    {
        fprintf(stdout, "Excute sql OK.\n");
    }

     printf("%d-%d-%d-%d-%d-%d\n", olt_temp->olt_index, olt_temp->onu_on_line,olt_temp->ui_port1,olt_temp->ui_port2,olt_temp->ui_port3,olt_temp->ui_port4);

    free(olt_temp);

    sqlite3_close(olt_db);
    return 0;
}

其中my_callback(void * pdata, int argc, char * value[], char *name[])为回调函数，切记回调函数只能按照这种格式来定义参数，
    第一个参数为你的主调函数传递过来的指针，
    第二个参数为变量的个数，
    第三个为变量的值，
    第四个为变量的名称，
    有两个问题需要注意：
        一、这里面参数都是字符串类型，根据您的需要作出强制类型转换即可。
        二、第一个参数为void *类型，需要在你的回调函数里强制转换成需要的类型。
 

Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1914908

Microsoft (R) Library Manager Version 6.00.8168 Copyright (C) Microsoft Corp 1992-1998. All rights reserved. Creating library SQLITE.lib and object SQLITE.exp
  这样就成功地创建了在WIN32程序中访问sqlite所需要的库,可以用于链接WIN32程序.
    到此所有使用sqlite的准备工作已告罄.现在在MSVC6中新建一个Win32 Console Application工程,把sqlite.dll,sqlite.h和sqlite.lib文件复制到工程文件夹中,把sqlite.h文件加入到项 目中,然后在Project Setting的Link中的对象库模块中增加sqlite.lib文件. 或者project->add to project->files，选择这个lib文件
然后修改加入如下代码即可:

#include <IOSTREAM>
#include <STRING>
#include <SSTREAM>
#include <stdio.h>
#include "sqlite3.h"

using namespace std;

sqlite3* pDB;

int createTable()
{
  char* errMsg;
  std::string dropTab="drop table test_tab;";
  string strSQL= "create table test_tab (f1 int, f2 long, f3 varchar(20));";
  int res = sqlite3_exec(pDB,dropTab.c_str(),0,0, &errMsg);
  if (res != SQLITE_OK)
  {
   std::cout << "执行SQL 出错." << errMsg << std::endl;
   //return -1;
  }

  res = sqlite3_exec(pDB,strSQL.c_str(),0,0, &errMsg);

  if (res != SQLITE_OK)
  {
    std::cout << "执行创建table的SQL 出错." << errMsg << std::endl;
    return -1;
  }
  else
  {
      std::cout << "创建table的SQL成功执行."<< std::endl;
  }

  return 0;
}

int insert1()
{
  char* errMsg;

  int res = sqlite3_exec(pDB,"begin transaction;",0,0, &errMsg);

  for (int i= 1; i < 100; ++i)
  {
    std::stringstream strsql;
    strsql << "insert into test_tab  values(";
    strsql  << i << ","<< (i+10) <<",'huyi'"<< ");";
    std::string str = strsql.str();
    cout << str <<endl;
    res = sqlite3_exec(pDB,str.c_str(),0,0, &errMsg);
    if (res != SQLITE_OK)
    {
      std::cout << "执行SQL 出错." << errMsg << std::endl;
      return -1;
    }
  }
  res = sqlite3_exec(pDB,"commit transaction;",0,0, &errMsg);
  std::cout << "SQL成功执行."<< std::endl;
  return 0;
}

int select1()
{
  char* errMsg;
 int nrow = 0, ncolumn = 0;
 char **azResult; //二维数组存放结果
  string strSQL= "select * from test_tab;";
     /*
  int res = sqlite3_exec(pDB,strSQL.c_str(),0,0, &errMsg);

  if (res != SQLITE_OK)
  {
    std::cout << "执行SQL 出错." << errMsg << std::endl;
    return -1;
  }
  else
  {
       std::cout << "SQL成功执行."<< std::endl;
  }
  */
  sqlite3_get_table(pDB, strSQL.c_str(), &azResult, &nrow, &ncolumn, &errMsg);
     int i = 0;
  for( i=0 ; i<( nrow + 1 ) * ncolumn ; i++ )
  {
   if (i>0 && i%ncolumn==0)
    printf("\n");
      printf( "%s ",azResult[i]);
  }
         printf("\n");
  //释放掉 azResult 的内存空间
  sqlite3_free_table( azResult );
  sqlite3_close(pDB); //关闭数据库
  return 0;
}

int main(int argc, char* argv[])
{
  if (argc < 2)
  {
    std::cout << "请输入命令行参数：sqlite数据库名." << std::endl;
    return 0;
  }

  int res = sqlite3_open(argv[1], &pDB);

  if( res ){
    std::cout << "Can't open database: "<< sqlite3_errmsg(pDB);
    sqlite3_close(pDB);
    return -1;
  }
  res = createTable();
  if (res != 0)
  {
      return 0;
  }
  res = insert1();
  if (res != 0)
  {
      return 0;
  }
  select1();
   return 0;
}