【转】【MySql】脚本备份数据库

#!/bin/bash
#this is a script of mysql backup
#Mysql="mysql"
#MysqlDump="mysqldump"
Host="192.168.1.101"
Port=""
User="root"
PassWord="******"
DataBaseName="test"
path=/home/luffy/mydata/backup/
binaryPath=/data1/
if [ ! -d $path ] ;then
 mkdir -p $path
fi
maxlog=
num=
cd $binaryPath
for file in $(ls |grep mysql-bin |grep -v index);do
    num=$(echo $file |cut -d '.' -f )
    if [ $num -gt $maxlog ];then
        maxlog=$num
    fi
done    #获取全备份时最大的二进制文件编号
cd $path
file=$(find . -type f -mtime - | grep .*all.sql)  #查找7天内是否有备份的文件
echo $file
if [ -z $file ] ;then
 echo "backup all databases..."
 backupfile=$(date +%F-%H-%M-%S)
 mysqldump -h$Host -u$User -p$PassWord -P$Port --lock-all-tables --flush-logs --master-data= --all-databases > $path"$backupfile-$maxlog-all.sql"
 if [ $? -eq  ] ;then
 echo "Accomplish,file is $backupfile-all.sql !"
 else
 echo " Failure !!! "
 fi
else                   #查找二进制文件，作增量备份
 echo "All database backups ,now start doing incremental backups!"
cd $path
    unset maxlog num file
    maxlog=
    num=
    for file in $(ls |grep mysql-bin |grep -v index);do
        num=$(echo $file |cut -d '.' -f  )
        if [ $num -gt $maxlog ];then
            maxlog=$num
        fi
    done         #获取最大的已备份的二进制文件
    unset num file
    num=
cd $binaryPath
    error=
    for file in $(ls |grep mysql-bin |grep -v index);do
        num=$(echo $file |cut -d '.' -f  )
        if [ $num -ge $maxlog ] ; then
        cp -f $binaryPath$file $path$file
        if [ $? -eq  ];then
        echo $file "Backup succeed"
        else
        echo $file "Backup error"
        error=$error+
        fi
        fi
    done
    if [ $error -eq  ] ;then
     echo "Backup completed"
    else
    echo "Backup fail"
    fi
fi

说明：此脚本每七天做一次完全备份，以后每天做一次增量备份，完全备份使用mysqldump客户端工具，增量备份使用mysqlbinlog备份其二进制日志文件。

增量备份是完全基于bin-log日志来进行的。

全备份脚本：

#/bin/bash
#Cwtea
#定义
Mysql="/usr/local/mysql5.5.32/bin/mysql"
MysqlDump="/usr/local/mysql5.5.32/bin/mysqldump"
User="root"
PassWord="*******"
DataBaseName="test"
WbBackup="/backup/mysql/Wb"
Now=`date +%Y-%m-%d`
#command
mkdir $Backup/$DataBaseName$Now
#mysqldump -uroot -p --single-transaction --all-databases  --flush-logs >Wb/Wb---.sql
$Mysql -u$User -p$PassWord -e "FLUSH TABLES;"
$MysqlDump -u$User -p$PassWord --single-transaction --all-databases  --flush-logs >$WbBackup/Wb-$Now.sql

增量备份脚本：

#/bin/bash
#Cwtea
#定义
MysqlAdmin="/usr/local/mysql5.5.32/bin/mysqladmin"
MysqlDump="/usr/local/mysql5.5.32/bin/mysqldump"
ZlBackup="/backup/mysql"
DataBaseName="test"
User="root"
PassWord="*******"
Now=`date +%Y-%m-%d`
#command
#mysqladmin -uroot -p**** flush-logs
$MysqlAdmin -u$User -p$PassWord flush-logs
#Update bin-log

备注：

　　find pathname -options [-print -exec -ok]
    //参数
        pathname: find命令所查找的目录路径。例如用 . 来表示当前目录，用 / 来表示系统根目录。
        -print：     find命令将匹配的文件输出到标准输出。
        -exec：     find命令对匹配的文件执行该参数所给出的shell命令。相应命令的形式为'command' {} \;，注意{ }和\；之间的空格。
        -ok：       和-exec的作用相同，只不过以一种更为安全的模式来执行该参数所给出的shell命令，在执行每一个命令之前，都会给出提示，让用户来确定是否执行。

 　　find命令选项
        -name：按照文件名查找文件。
        -perm：按照文件权限来查找文件。
        -prune：使用这一选项可以使find命令不在当前指定的目录中查找，如果同时使用-depth选项，那么-prune将被find命令忽略。
        -user： 按照文件属主来查找文件。
        -group：按照文件所属的组来查找文件。
        -mtime -n +n：按照文件的更改时间来查找文件， - n表示文件更改时间距现在n天以内，+n表示文件更改时间距现在n天以前。Find命令还有-atime和-ctime选项，但它们都和-mtime选项。
        -nogroup：查找无有效所属组的文件，即该文件所属的组在/etc/groups中不存在。
        -nouser：查找无有效属主的文件，即该文件的属主在/etc/passwd中不存在。
        -newer file1 ! file2：查找更改时间比文件file1新但比文件file2旧的文件
        -type 查找某一类型的文件
                b - 块设备文件。
                d - 目录。
                c - 字符设备文件。
                p - 管道文件。
                l - 符号链接文件。
                f - 普通文件
        -size n：[c] 查找文件长度为n块的文件，带有c时表示文件长度以字节计。
        -depth：在查找文件时，首先查找当前目录中的文件，然后再在其子目录中查找。
        -fstype：查找位于某一类型文件系统中的文件，这些文件系统类型通常可以在配置文件/etc/fstab中找到，该配置文件中包含了本系统中有关文件系统的信息
                -mount：在查找文件时不跨越文件系统mount点。
                -follow：如果find命令遇到符号链接文件，就跟踪至链接所指向的文件。
                -cpio：对匹配的文件使用cpio命令，将这些文件备份到磁带设备中

实例
  当前目录及子目录中查找文件名以一个大写字母开头的文件
            find . -name "[A-Z]*" -print
  在/etc目录中查找文件名以host开头的文件
            find /etc -name "host*" -print

find 其他参数
 exec
    find命令将所有匹配到的文件一起传递给exec执行
    有些系统对能够传递给exec的命令长度有限制，这样在find命令运行几分钟之后，就会出现溢出错误
    xargs命令每次只获取一部分文件而不是全部
    匹配当前目录下的所有普通文件
            find . -type f -exec ls -l {} \;
    在/ logs目录中查找更改时间在5日以前的文件并删除它们
            find logs -type f -mtime +5 -exec rm {} \;
    在当前目录中查找所有文件名以.log结尾、更改时间在5日以上的文件，并删除它们，在删除之前先给出提示
            find . -name "*.log" -mtime +5 -ok rm {} \;
    首先匹配所有文件名为“ passwd*”的文件，然后执行grep命令查看这些文件中是否存在一个sam用户
            find /etc -name "passwd*" -exec grep "sam" {} \;
    查找当前用户主目录下的所有文件
            find $HOME -print
            find ~ -print
    在当前目录中文件属主具有读、写权限，并且文件所属组的用户和其他用户具有读权限的文件
            find . -type f -perm 644 -exec ls -l {} \;
    查找系统中所有文件长度为0的普通文件，并列出它们的完整路径
            find / -type f -size 0 -exec ls -l {} \;
    查找系统中所有属于root组的文件
            find . -group root -exec ls -l {} \;
    查找当前目录中的所有目录并排序
            find . -type d |sort
xargs
    前面的输出转换为后方指令的参数输入
    使用exec和xargs可以使用户对所匹配到的文件执行几乎所有的命令。
    查找系统中的每一个普通文件，然后使用xargs命令测试它们分别属于哪类文件
        find . -type f -print | xargs file
    在整个系统中查找内存信息转储文件(core dump) ，然后把结果保存到/tmp/core.log 文件中
        find / -name "core" -print | xargs echo "" >/tmp/core.log
    在当前目录下查找所有用户具有读、写和执行权限的文件，并收回相应的写权限
        find . -perm -7 -print | xargs chmod o-w
    用grep命令在所有的普通文件中搜索hostname这个词
        find . -type f -print | xargs grep "hostname"
    统计当前目录下所有文件的大小,含子目录,精确到字节
        find ./ -type f | xargs ls -l | awk 'BEGIN{size=0}{size+=$5};END{print size}'

   $: shell或shell脚本的名字
   $*:以一对双引号给出参数列表
   $@:将各个参数分别加双引号返回
   $#:参数的个数
   $_:代表上一个命令的最后一个参数
   $$:代表所在命令的PID
   $!:代表最后执行的后台命令的PID
   $?:代表上一个命令执行后的退出状态

-eq 等于,如:if [ "$a" -eq "$b" ]
-ne 不等于,如:if [ "$a" -ne "$b" ]
-gt 大于,如:if [ "$a" -gt "$b" ]
-ge 大于等于,如:if [ "$a" -ge "$b" ]
-lt 小于,如:if [ "$a" -lt "$b" ]
-le 小于等于,如:if [ "$a" -le "$b" ]
<   小于(需要双括号),如:(("$a" < "$b"))
<=  小于等于(需要双括号),如:(("$a" <= "$b"))
>   大于(需要双括号),如:(("$a" > "$b"))
>=  大于等于(需要双括号),如:(("$a" >= "$b"))   

-e                          文件存在
-a                          文件存在（已被弃用）
-f                          被测文件是一个regular文件（正常文件，非目录或设备）
-s                          文件长度不为0
-d                          被测对象是目录
-b                          被测对象是块设备
-c                          被测对象是字符设备
-p                          被测对象是管道
-h                          被测文件是符号连接
-L                          被测文件是符号连接
-S(大写)                    被测文件是一个socket
-t                          关联到一个终端设备的文件描述符。用来检测脚本的stdin[-t0]或[-t1]是一个终端
-r                          文件具有读权限，针对运行脚本的用户
-w                          文件具有写权限，针对运行脚本的用户
-x                          文件具有执行权限，针对运行脚本的用户
-u                          set-user-id(suid)标志到文件，即普通用户可以使用的root权限文件，通过chmod +s file实现
-k                          设置粘贴位
-O                          运行脚本的用户是文件的所有者
-G                          文件的group-id和运行脚本的用户相同
-N                          从文件最后被阅读到现在，是否被修改

f1 -nt f2                   文件f1是否比f2新
f1 -ot f2                   文件f1是否比f2旧
f1 -ef f2                   文件f1和f2是否硬连接到同一个文件

-mtime n 按照文件的更改时间来找文件，n为整数。
//n表示文件更改时间距离为n天， -n表示文件更改时间距离在n天以内，+n表示文件更改时间距离在n天以前。
//例如：
-mtime  表示文件修改时间距离当前为0天的文件，即距离当前时间不到1天（24小时）以内的文件。
-mtime  表示文件修改时间距离当前为1天的文件，即距离当前时间1天（24小时－48小时）的文件。
-mtime＋ 表示文件修改时间为大于1天的文件，即距离当前时间2天（48小时）之外的文件
-mtime - 表示文件修改时间为小于1天的文件，即距离当前时间1天（24小时）之内的文件

//为什么-mtime＋1 表示文件修改时间为大于1天的文件，即距离当前时间48小时之外的文件，而不是24小时之外的呢？
因为n值只能是整数，即比1大的最近的整数是2,所有-mtime＋1不是比当前时间大于1天（24小时），而是比当前时间大于2天（48小时）。

for循环应用：
.
for i in $(seq  ); do
        echo $i
done
.
for (( i =  ; $i <= ; i++ )) ;do
         echo $i;
done

if条件判断：

1、字符串判断
str1 = str2　　　　　　当两个串有相同内容、长度时为真
str1 != str2　　　　　 当串str1和str2不等时为真
-n str1　　　　　　　 当串的长度大于0时为真(串非空)
-z str1　　　　　　　 当串的长度为0时为真(空串)
str1　　　　　　　　   当串str1为非空时为真
2、数字的判断
int1 -eq int2　　　　两数相等为真
int1 -ne int2　　　　两数不等为真
int1 -gt int2　　　　int1大于int2为真
int1 -ge int2　　　　int1大于等于int2为真
int1 -lt int2　　　　int1小于int2为真
int1 -le int2　　　　int1小于等于int2为真
3、文件的判断
-r file　　　　　用户可读为真
-w file　　　　　用户可写为真
 -x file　　　　　用户可执行为真
-f file　　　　　文件为正规文件为真
-d file　　　　　文件为目录为真
-c file　　　　　文件为字符特殊文件为真
-b file　　　　　文件为块特殊文件为真
-s file　　　　　文件大小非0时为真
-t file　　　　　当文件描述符(默认为1)指定的设备为终端时为真
4、复杂逻辑判断
-a 　 　　　　　 与
-o　　　　　　　 或
!　　　　　　　　非

unset命令用于删除已定义的shell变量（包括环境变量）和shell函数。
unset命令不能够删除具有只读属性的shell变量和环境变量。

语法 unset(选项)(参数)
-f：
    仅删除函数；
-v：
    仅删除变量。

cut
cut 命令可以从一个文本文件或者文本流中提取文本列。
cut语法
[root@www ~]# cut -d'分隔字符' -f fields <==用于有特定分隔字符
[root@www ~]# cut -c 字符区间            <==用于排列整齐的信息
选项与参数：
-d  ：后面接分隔字符。与 -f 一起使用；
-f  ：依据 -d 的分隔字符将一段信息分割成为数段，用 -f 取出第几段的意思；
-c  ：以字符 (characters) 的单位取出固定字符区间；
PATH 变量如下
[root@www ~]# echo $PATH
/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin:/usr/X11R6/bin:/usr/games
#  |        |    |        |             |             |
将 PATH 变量取出，我要找出第五个路径。
#echo $PATH | cut -d ':' -f
/usr/local/bin
将 PATH 变量取出，我要找出第三和第五个路径。
#echo $PATH | cut -d ':' -f ,
/sbin:/usr/local/bin
将 PATH 变量取出，我要找出第三到最后一个路径。
echo $PATH | cut -d ':' -f -
/sbin:/usr/sbin:/usr/local/bin:/usr/X11R6/bin:/usr/games
将 PATH 变量取出，我要找出第一到第三个路径。
#echo $PATH | cut -d ':' -f -
/bin:/usr/bin:/sbin:
将 PATH 变量取出，我要找出第一到第三，还有第五个路径。
echo $PATH | cut -d ':' -f -,
/bin:/usr/bin:/sbin:/usr/local/bin

grep是UNIX和Linux中使用最广泛的命令之一。grep（全局正则表达式版本）允许对文本文件进行模式查找。如果找到匹配模式，grep打印包含模式的所有行。grep支持基本正则表达式，也支持其扩展集。

grep [选项]基本正则表达式[文件]
    -c          只输出匹配行的计数。
    -i          不区分大小写（只适用于单字符）。
    -h          查询多文件时不显示文件名。
    -l          查询多文件时只输出包含匹配字符的文件名。
    -n          显示匹配行及行号。
    -s          不显示不存在或无匹配文本的错误信息。
    -v          显示不包含匹配文本的所有行。

二元比较操作符，比较变量或比较数字

整数比较：

-eq                       等于            if [ "$a" -eq "$b" ]
-ne                       不等于          if [ "$a" -ne "$b" ]
-gt                       大于            if [ "$a" -gt "$b" ]
-ge                       大于等于        if [ "$a" -ge "$b" ]
-lt                       小于            if [ "$a" -lt "$b" ]
-le                       小于等于        if [ "$a" -le "$b" ]

<                         小于（需要双括号）           (( "$a" < "$b" ))
<=                        小于等于(...)                (( "$a" <= "$b" ))
>                         大于(...)                    (( "$a" > "$b" ))
>=                        大于等于(...)                (( "$a" >= "$b" ))

字符串比较：

=                         等于           if [ "$a" = "$b" ]
==                        与=等价
!=                        不等于         if [ "$a" = "$b" ]
<                         小于，在ASCII字母中的顺序：
                          if [[ "$a" < "$b" ]]
                          if [ "$a" \< "$b" ]         #需要对<进行转义
>                         大于

-z                        字符串为null，即长度为0
-n                        字符串不为null，即长度不为0

注意：

比较两个字符串是否相等的办法是：

if [ "$test"x = "test"x ]; then

这里的关键有几点：

1 使用单个等号

2 注意到等号两边各有一个空格：这是unix shell的要求

3 注意到"$test"x最后的x，这是特意安排的，因为当$test为空的时候，上面的表达式就变成了x = testx，显然是不相等的。而如果没有这个x，表达式就会报错：[: =: unary operator expected

注意:==的功能在[[]]和[]中的行为是不同的,如下:

 [[ $a == z* ]]   # 如果$a以"z"开头(模式匹配)那么将为true
 [[ $a == "z*" ]] # 如果$a等于z*(字符匹配),那么结果为true   

 [ $a == z* ]     # File globbing 和word splitting将会发生
 [ "$a" == "z*" ] # 如果$a等于z*(字符匹配),那么结果为true   

一点解释,关于File globbing是一种关于文件的速记法,比如"*.c"就是,再如~也是.

但是file globbing并不是严格的正则表达式,虽然绝大多数情况下结构比较像. 
!= 不等于,如:if [ "$a" != "$b" ] 
这个操作符将在[[]]结构中使用模式匹配. 
< 小于,在ASCII字母顺序下.如: 
if [[ "$a" < "$b" ]] 
if [ "$a" \< "$b" ] 
注意:在[]结构中"<"需要被转义. 
> 大于,在ASCII字母顺序下.如: 
if [[ "$a" > "$b" ]] 
if [ "$a" \> "$b" ] 
注意:在[]结构中">"需要被转义. 
具体参考Example 26-11来查看这个操作符应用的例子. 
-z 字符串为"null".就是长度为0. 
-n 字符串不为"null" 
注意: 
使用-n在[]结构中测试必须要用""把变量引起来.使用一个未被""的字符串来使用! -z 
或者就是未用""引用的字符串本身,放到[]结构中。虽然一般情况下可

以工作,但这是不安全的.习惯于使用""来测试字符串是一种好习惯.

还原说明：

MySQL binlog就是mysql的二进制数据文件。在对mysql进行一些配置之后，mysql会把数据库的更新操作都记录在一个文件中。

mysql binlog可以在mysqld的--bin-log选项或者在配置文件(my.cnf或者my.ini)中打开。

[mysqld]
log-bin=mysql-bin   //[必须]启用二进制日志

在启用了二进制日志以后，在mysql的数据目录下，会出现一些以数字为结尾的文件，例如：

-rw-rw---- 1 guilhem  guilhem   1277324 Nov 10 23:59 mysql-bin.000001
-rw-rw---- 1 guilhem  guilhem         4 Nov 10 23:59 mysql-bin.000002

这些文件就是二进制的日志文件。每次mysql启动都会增加一个文件。

那么如何采用全量mysqldump+增量mysqlbinlog的方式进行数据恢复？从mysqldump备份文件恢复数据会丢失掉从备份点开始的更新数据，所以还需要结合mysqlbinlog二进制日志增量备份。确保my.ini或者my.cnf中包含下面的配置以启用二进制日志。

方法其实很简单，在每次使用mysqldump进行全量数据备份时，用--flush-logs选项：

mysqldump --single-transaction --flush-logs --master-data=2 > mysqlpub_backup.sql

在使用这样的语句进行备份之后，mysql就会关闭原来的二进制日志文件，开启一个新的二进制日志文件。比如，新开启、新增量的二进制日志文件为 mysql-bin.000003。 那么在进行数据恢复的时候，你可以利用backup.sql进行全量恢复+ mysql-bin.000003进行增量同步。

数据恢复的方法也很简单：

shell> mysql -uroot -pPwd < msyqlpub_backup.sql  （或 cat mysqlpub_backup.sql | mysql -uroot -ppassword ）
shell> mysqlbinlog mysql-bin.000003 | mysql -uroot -ppassword

mysqlbinlog是一个读取 mysql二进制日志输出sql语句的命令行工具。

使用方法可以从 http://doc.mysql.cn/mysql5/refman-5.1-zh.html-chapter/client-side-scripts.html#mysqlbinlog 查到。

此外mysqlbinlog还可以指定--start-date、--stop-date、--start-position和--stop-position参数，用于精确恢复数据到某个时刻之前或者跳过中间某个出问题时间段恢复数据，直接摘录MySQL文档说明中相关内容如下：

5.9.3.1. 指定恢复时间
对于MySQL 4.1.4，可以在mysqlbinlog语句中通过--start-date和--stop-date选项指定DATETIME格式的起止时间。举例说明，假设在今天上午10:00(今天是2005年4月20日)，执行SQL语句来删除一个大表。要想恢复表和数据，你可以恢复前晚上的备份，并输入：

mysqlbinlog --stop-date="2005-04-20 9:59:59" /var/log/mysql/bin.123456 | mysql -u root -pmypwd

该命令将恢复截止到在--stop-date选项中以DATETIME格式给出的日期和时间的所有数据。如果你没有检测到几个小时后输入的错误的SQL语句，可能你想要恢复后面发生的活动。根据这些，你可以用起使日期和时间再次运行mysqlbinlog：

mysqlbinlog --start-date="2005-04-20 10:01:00" /var/log/mysql/bin.123456 | mysql -u root -pmypwd 

在该行中，从上午10:01登录的SQL语句将运行。组合执行前夜的转储文件和mysqlbinlog的两行可以将所有数据恢复到上午10:00前一秒钟。你应检查日志以确保时间确切。下一节介绍如何实现。

5.9.3.2. 指定恢复位置
也可以不指定日期和时间，而使用mysqlbinlog的选项--start-position和--stop-position来指定日志位置。它们的作用与起止日选项相同，不同的是给出了从日志起的位置号。使用日志位置是更准确的恢复方法，特别是当由于破坏性SQL语句同时发生许多事务的时候。要想确定位置号，可以运行mysqlbinlog寻找执行了不期望的事务的时间范围，但应将结果重新指向文本文件以便进行检查。操作方法为：

mysqlbinlog --start-date="2005-04-20 9:55:00" --stop-date="2005-04-20 10:05:00" /var/log/mysql/bin.123456 > /tmp/mysql_restore.sql

该命令将在/tmp目录创建小的文本文件，将显示执行了错误的SQL语句时的SQL语句。你可以用文本编辑器打开该文件，寻找你不要想重复的语句。如果二进制日志中的位置号用于停止和继续恢复操作，应进行注释。用log_pos加一个数字来标记位置。使用位置号恢复了以前的备份文件后，你应从命令行输入下面内容：

mysqlbinlog --stop-position="368312" /var/log/mysql/bin.123456 | mysql -u root -pmypwd
mysqlbinlog --start-position="368315" /var/log/mysql/bin.123456 | mysql -u root -pmypwd 

上面的第1行将恢复到停止位置为止的所有事务。下一行将恢复从给定的起始位置直到二进制日志结束的所有事务。因为mysqlbinlog的输出包括每个SQL语句记录之前的SET TIMESTAMP语句，恢复的数据和相关MySQL日志将反应事务执行的原时间。

脚本使用说明：

1. 第一行必须是"#!/bin/sh"

• 它不是注释，"#!/bin/sh"是对shell的声明，说明你所用的是那种类型的shell及其路径所在；
• 如果没有声明，则脚本将在默认的shell中执行，默认shell是由用户所在的系统定义为执行shell脚本的shell.
• 如果脚本被编写为在Kornshell ksh中运行，而默认运行shell脚本的为C shell csh,则脚本在执行过程中很可能失败。
• 所以建议大家就把"#!/bin/sh"当成C 语言的main函数一样，写shell必须有，以使shell程序更严密。

2. 注释：一行开头为 #

3. 定义变量

定义单变量

p_name='kang'

使用单变量

echo  $p_name'.js'    # 输出kang.js
echo  $p_name.js      # 输出kang.js
cp  $p_name.js  copy.js;

4. 逻辑符号

命令1 && 命令2

如果左边的“命令1”执行成功，那么右边的“命令2”才会被执行。

命令1 || 命令2

与&&相反。如果“命令1”未执行成功，那么就执行“命令2”。

() {}

...

5. 接收参数

脚本文件“copy.sh”，其内容如下：

m=$1
n=$2
echo $m-$n

执行命令：“sh copy.sh 111 222”；输出 111-222

6. 控制流：if/then/elif/else/fi

注意"["和"]"前后的空格必须有，否则提示错误

m="kang2"
if [ "$m" == 'kang' ]; then
    echo 'kang'
elif [ $m == 'kang2' ]; then
    echo 'kang2'
else
    echo 'no'
fi

示例：判断文件夹

if [ -d './js' ]; then
 echo 'js是文件夹'
fi

7. 循环：for/do/done

注意：循环项是以“空格”拆分的字符串

name="rain man's blog"
for loop in $name; do
    echo $loop;
done

8. 格式化输出日期

curdate="`date +%Y%m%d%H%M%S`"
echo $curdate

执行结果：20110904175817

9. exist

退出当前shell脚本，一般来说，返回0表示执行成功，其他值表示没有执行成功。

exist 0    # 返回0
exist 1    # 返回1

10. 系统变量

pwd=$PWD      # 当前目录
user=$USER    # 当前用户
echo $pwd
echo $user

运行脚本后输出：

/home/rainman/test
rainman

11. 系统变量

public static class SQLBackup
    {
        /// <summary>
        /// 执行Cmd命令
        /// </summary>
        /// <param name="workingDirectory">要启动的进程的目录</param>
        /// <param name="command">要执行的命令</param>
        public static void StartCmd(String workingDirectory, String command)
        {
            using (Process p = new Process())
            {
                p.StartInfo.FileName = "cmd.exe";
                p.StartInfo.WorkingDirectory = workingDirectory;
                p.StartInfo.UseShellExecute = false;
                p.StartInfo.RedirectStandardInput = true;
                p.StartInfo.RedirectStandardOutput = true;
                p.StartInfo.RedirectStandardError = true;
                p.StartInfo.CreateNoWindow = true;
                //p.EnableRaisingEvents = true;
                p.Start();
                p.StandardInput.WriteLine(command);
                p.StandardInput.WriteLine("exit");
                //p.StandardInput.Flush();
                string error = p.StandardError.ReadToEnd();
                p.WaitForExit();
                if (!string.IsNullOrEmpty(error) && (error.ToLower().Contains("error")))
                    throw new System.Data.DataException(error);
            }
        }
        /// <summary>
        /// 数据库备份
        /// </summary>
        /// <param name="ip">数据库IP</param>
        /// <param name="port">数据库端口</param>
        /// <param name="dbName">数据库名</param>
        /// <param name="userName">用户名</param>
        /// <param name="userPsw">用户密码</param>
        /// <param name="filepath">本分路径</param>
        /// <param name="characterset">数据库数据格式</param>
        public static void Backup(string ip, string port, string dbName, string userName, string userPsw, string filepath, string characterset = "utf8")
        {
            try
            {
                //String command = "mysqldump --quick --host=localhost --default-character-set=gb2312 --lock-tables --verbose  --force --port=端口号 --user=用户名 --password=密码 数据库名 -r 备份到的地址";
                string command = string.Format("mysqldump --quick --host=" + ip + " --default-character-set=" + characterset + " --lock-tables --verbose --force --port=" + port + " --user=" + userName + " --password=" + userPsw + " --databases " + dbName + " --add-drop-database -R -r \"{0}\"", filepath);
                //if (!System.IO.File.Exists(Environment.CurrentDirectory + "\\gzip.exe"))
                //{
                //    throw new Exception("无法完成数据库备份，请检查 gzip.exe 是否存在。");
                //}
                //command = "\"" + Environment.CurrentDirectory + "\\mysqldump.exe\"  -h " + ip + " -u" + userName + " -p " + userPsw + " --hex-blob  --default-character-set " + characterset + " -R --opt --add-drop-table -f " + dbname + " | \"" + Environment.CurrentDirectory + "\\gzip.exe\">\"" + filepath + "\"";
                //获取mysqldump.exe所在路径
                String appDirecroty = System.Windows.Forms.Application.StartupPath + "\\";
                StartCmd(appDirecroty, command);
            }
            catch (Exception ex)
            {
                throw new Exception("数据库备份失败！\r\n" + ex.ToString());
            }
        }
        /// <summary>
        /// 数据库还原
        /// </summary>
        /// <param name="ip">数据库IP</param>
        /// <param name="port">数据库端口</param>
        /// <param name="dbName">数据库名</param>
        /// <param name="userName">用户名</param>
        /// <param name="userPsw">用户密码</param>
        /// <param name="filepath">本分路径</param>
        /// <param name="characterset">数据库数据格式</param>
        public static void Restore(string ip, string port, string dbName, string userName, string userPsw, string filepath, string characterset = "utf8")
        {
            try
            {
                //string command = "mysql --port=端口号 --user=用户名 --password=密码 数据库名<还原文件所在路径";
                //在文件路径后面加上""避免空格出现异常
                string command = string.Format("mysql --host=" + ip + " --default-character-set=" + characterset + " --port=" + port + " --user=" + userName + " --password=" + userPsw + " <\"{0}\"", filepath);
                ////判断是不是压缩文件
                //if (filepath.EndsWith(".gz"))
                //{
                //    if (!System.IO.File.Exists(Environment.CurrentDirectory + "\\gzip.exe"))
                //    {
                //        throw new Exception("无法完成数据库恢复，请检查 gzip.exe 是否存在。");
                //    }
                //    command = "\"" + Environment.CurrentDirectory+ "\\gzip.exe\" -k -d \"" + filepath + "\"";
                //    String appDirecroty = System.Windows.Forms.Application.StartupPath + "\\";
                //    StartCmd(appDirecroty, command);
                //}
                //获取mysql.exe所在路径
                String appDirecroty = System.Windows.Forms.Application.StartupPath + "\\";
                StartCmd(appDirecroty, command);
            }
            catch (Exception ex)
            {
                throw new Exception("数据库还原失败！\r\n" + ex.ToString());
            }

        }
    }

参考地址：　http://www.jb51.net/article/69294.htm

　　　　　　http://www.cnblogs.com/yanghj010/p/5076118.html

　　　　　　http://www.mysqlpub.com/thread-59601-1-1.html