SQLSERVER（三）

1.SQLServer登录

　　1.1SQlServer三层安全管理机制

　　　　包括登录名、数据库、操作数据库权限

　　　　一个登录名对应多个数据库用户，属于一对多；一个数据库用户对应一个数据库，属于一对一

　　1.2登录名（登陆账户）

　　　　用以登录SQL Server数据库服务器；一个数据库服务器可能有若干个数据库

　　1.3数据库用户

　　　　用于访问指定的数据库。登陆成功后，根据登录名找到对应的数据库用户，再去访问某个具体的用户数据库。找到该数据库用户对应的权限，操作数据库

2.添加登陆账户

　　登录账户sa是超级管理员账户，拥有数据库管理的最高权限，可以管理所有的数据库，安装时自动创建

use master
go
exec sp_addlogin 'YangSan','1001'
--账户名是“YangSan”,密码是“1001”，中间用逗号隔开

 3.向数据库用户授权

　　3.1授权的语法

　　　　grant 权限[on 表名] to 数据库用户　　　　

　　3.2收回权限的语法

　　　　remoke 权限[on 表名] to 数据库用户

4.变量分类

　　局部变量：仅在过程中使用

　　　　局部变量必须以标记@作为前缀，如@age

　　　　局部变量的使用也是先声明（使用declare），再赋值

　　全局变量：任何时候均可以使用

　　　　全部变量必须以标记@@作为前缀，如@@version（查询版本）

　　　　全局变量由系统定义和维护，我们只能读取，不能修改全局变量

5.局部变量定义与赋值

　　局部变量的定义语法：declare @变量名 数据类型

　　赋值方法： set @变量名=值    或   select @变量名=值 （使用select赋值要确保筛选出的记录只有一条）

use SMDB
go
--声明变量
declare @stuName varchar(20),@stuId int
--赋值变量
set @stuName='李铭'
select @stuId=StudentId from Students where Studentname=@stuName
--事先查询下李铭的信息
select StudentName,StudentId,Gender from Students where StudentName=@stuName

--查询李铭学号前后学员的信息
select StudentName,StudentId,Gender from Students 
where StudentId=(@stuId-1) or StudentId=@stuId or StudentId=(@stuId+1)
order by StudentId DESC

select StudentId,StudentName from Students
where StudentId in (@stuId-1,@stuId,@stuId+1)

select @@servername as '服务器名称'

6.set与select比较

使用场景	set	select
同时对多个变量赋值	不支持	支持
表达式返回多个值时	出错	将返回的最后一个值赋给变量
表达式未返回值时	变量被赋NULL值	变量保持原值

　　就赋值而言，set能做的select都能做。查询尽量多用select

declare @stuAddress nvarchar(100),@stuName nvarchar(100)
--set @stuAddress='昆山',@stuName='张三' --不允许这样赋值
select @stuAddress='昆山',@stuName='张三'  --允许

--set @stuAddress = (select StudentAddress from Students) --不允许
select @stuAddress = StudentAddress from Students --得到最后一个
--set @stuAddress = (select StudentAddress from Students where 1<0) --Null值
select @stuAddress = StudentAddress from Students where 1<0 --保持原值

select @stuAddress as '地址',@stuName as '姓名'

7.全局变量的使用

变量	含义
@@ERROR	最后一个T—SQL错误的错误号
@@IDENTITY	最后一次插入的标识值
@@LANGUAGE	当前使用的语言的名称
@@MAX_CONNECTIONS	可以创建的同时连接的最大数目
@@ROWCOUNT	受上一个SQL语句影响的行数
@@SERVERNAME	本地服务器的名称
@@TRANSCOUNT	当前连接打开的事务数
@@VERSION	SWL Server的版本信息

8.错误号的使用

　　@@error 全局变量保留错误号

use SMDB 
go
select * from StudentClass
--插入一条学员信息，但班级为10，当前没有此班级
--会引发外键冲突
insert into Students(StudentName,Gender,Age,Birthday,StudentIdNo,CardNo,PhoneNumber,STudentAddress,ClassId)
values('王小欣','男',24,'1992-9-9',42109876543456,2011129876,'0512-88765678','昆山',10)

print @@error

            //删除一名学生，但成绩表还有改学生信息，是不能被删除的
            string sql = "delete from Students where StudentId=" + studentId;
            try
            {
                return SQLHelper.Update(sql);
            }
            catch (SqlException ex)
            {
                if (ex.Number == 547)
                    throw new Exception("该学号被其他实体引用，不能直接删除该学员对象！");
                else
                    throw new Exception("数据库操作出现异常！具体信息：
" + ex.Message);
            }
            catch (Exception ex)
            {
                throw ex;
            }
    

 9.数据类型转换

　　convert(数据类型，表达式，样式)

　　　　第三个参数可以省略，它一般用于日期类型转换为字符来行，或浮点类型数据转换为字符类型

　　cast(表达式 as 数据类型)

 

10.if_else语句

--SQL中的if语句
if(条件)
    begin
        语句1
        语句2
        ......
    END
else
    begin
        语句1
        语句2
        ......
    end

--注：else是可选部分
--如果有多条语句，才需要begin-end语句块，相当于c#中的{ }

use SMDB 
go
declare @avg int
select @avg=avg(CSharp) from ScoreList 
inner join Students on Students.StudentId=ScoreList.StudentId
where Students.ClassId=1
print 'CSharp平均分：'+convert(varchar(20),@avg)
--执行判断
if(@avg>=80)
    print '成绩合格'
else
    print '成绩不合格'

11.while语句

--SQL中的while语句
while(条件)
    begin
        语句1
        语句2
        ......
        break
    end
--break表示跳出循环
--如果有多条语句，才需要begin-end语句块

12.case_end语句

case
    when 条件1 then 结果1
    when 条件2 then 结果2
    ......
    else 其他结果
end
--else表示case中所有when条件均不为then是返回的结果，相当于C#中的default
--如果省略else且when条件都为false时，case语句返回null

use SMDB 
go
select 学号=Students.StudentId,姓名=Studentname,C#成绩=CSharp,
       等级=case
                when CSharp>=90 then 'A'
                when CSharp between 80 and 89 then 'B'
                when CSharp between 70 and 79 then 'C'
                when CSharp between 60 and 69 then 'D'
                else '不及格'
            end
from ScoreList inner join Students on ScoreList.StudentId=Students.StudentId

 13.子查询

　　语法规范：子查询（总是用括号括起来）

　　　　select ... from 表1 where 字段1 比较运算符（子查询）

　　子查询注意：

　　　　将子查询与比较运算符联合使用，必须保证子查询返回的值不能多于1个

　　　　子查询是一个嵌套在select、insert、update、update或delete语句或其他子查询中的查询

　　理解子查询执行过程：

　　　　首先，执行小括号中的子查询，返回的结果是所有子查询的结果

　　　　其次，才开始执行外围的父查询，返回查询的最终结果

use SMDB
go
--查询学号在赵小金后面的学员信息

--方法一：定义变量，可读性好
declare @stuId int
select @stuId=StudentId from Students where Studentname='赵小金'
select StudentId,Studentname from Students where StudentId>@stuId

--父查询中嵌套子查询
select StudentId,Studentname from Students 
where StudentId>(select StudentId from STudents where Studentname='赵小金')

14.in子查询（范围查询 in 后面类似数组）

　　in后面的子查询可以返回多条记录

　　常用in替换等于=的比较子查询 

　　not in 表示不在此范围

use SMDB
go
select Students.StudentId,StudentName from Students
inner join ScoreList on ScoreList.StudentId=Students.StudentId
where SQLServerDB>80

select StudentId,StudentName from Students
where StudentId in (select StudentId from ScoreList where SQLServerDB>80)

--查询没有参加考试的学员
select StudentId,Studentname from Students
where StudentId not in(select StudentId from ScoreList)

15.exists子查询（判断是否存在）

　　if exists (子查询)

　　   语句

　　查询结果非空，记录数1条以上，则exists子查询返回真，否则返回假

　　not exists 不存在

use master
go
if exists(select * from sysdatabases where name='SMDB')
print '数据库已存在'

use SMDB
go
if    exists(select * from sysobjects where name='Students')
print '数据表已存在'

 16.视图

　　视图的概念：

1. 1. 是存储在服务器端的一个查询块，是一张虚拟表
   2. 表示一张表的部分数据或多张表的综合数据
   3. 其结构和数据是建立在对表的查询基础上
   4. 视图的使用，跟对普通的表的查询使用完全一样

 　　视图中不存放数据：数据存放在视图所引用的原始表中

　　表视图的多样性：一个或多个原始表，根据不同用户的不同需求，可以创建不同的视图

　　视图的用途：

1. 1. 筛选表中的行
   2. 防止未经许可的用户访问敏感数据
   3. 降低数据库的复杂程度
   4. 将多个物理数据库抽象成一个逻辑数据库

 　　视图可以手动创建，简单快捷，引用查询视图像引用表一样简单快捷

　　select * from V_Stu 

17.创建和使用视图

create view view_StuInfo
    as
    <select 语句>

if exists(select * from sysobjects where name=view_StuInfo)
    drop view view_StuInfo

select * from view_StuInfo

use SMDB
go
--判断视图是否存在
if exists(select * from sysobjects where name='V_StuScore')
drop view V_StuScore
go
--创建视图
create view V_StuScore
as
    select top 100 ID=Students.StudentId,姓名=StudentName,班级=ClassName,C#=CSharp,
    SQL=SQLServerDB,总分=(CSharp+SQLServerDB) from Students 
    inner join ScoreList on Students.StudentId=ScoreList.StudentId
    inner join StudentClass on StudentClass.ClassId=Students.ClassId
    order by 总分 DESC
go

select * from V_StuScore order by ID asc

18.视图中select语句不能包括下列内容（视图相对于存储过程的不足）

1. order by子句，除非在select语句得选择列表中有top子句
2. into子句
3. 引用临时表或变量：视图只能查询，不能增删改，视图仅表示一种查询的逻辑关系，视图内不包括实体数据

19.存储过程

　　概念：

1. 1. 预先存储好的SQL程序
   2. 保存在SQL Server中（跟视图一样）
   3. 通过名称和参数执行：可以在数据库服务器端直接调用（DBA）、供应用程序调用可带参数、可返回结果
   4. 可以包含数据操纵语句（单个select语句或select语句块）、变量、逻辑控制语句等

　　优点：

1. 1. 执行速度块
   2. 允许模块化程序设计
   3. 提高系统安全性
   4. 减少网络流通量
   5. 视图和存储过程的重要优点：安全且执行速度块

　　SQL语句和存储过程的比较：

1. 1. 应用程序发送SQL的过程：  传输语句——>>>语法检查——>>>语法优化——>>>语句编译——>>>语法执行
   2. 调用存储过程或视图过程：  传输参数——>>>语句执行

　　存储过程分类：

1. 1. 系统存储过程：以“sp_”开头，由SQL Server创建、管理和使用，存放在master数据库中，类似于C#语言类库中的方法
   2. 扩展存储过程：以“xp_”开头，使用编程语言（C#）创建的外部存储过程，以DLL形式单独存在  xp_cmdshell：可以执行DOS命令下的一些操作，以文本方式返回任何输出
   3. 用户自定义存储过程：由用户在自己的数据库中创建的存储过程，类似于C#中程序员自定义的方法

系统存储过程	说明
sp_databases	列出数据库上的所有数据库
sp_helpdb	报告有关指定数据库或所有数据库的信息
sp_renamedb	更改数据库的名称
sp_tables	返回当前环境下可查询的对象的列表
sp_columns	返回某个表列的信息
sp_help	查看某个表的所有信息
sp_helpconstraint	查看某个表的约束
sp_helpindex	查看某个表的索引
sp_stored_procedures	列出当前环境中的所有存储过程
sp_password	添加或修改登录账户的密码
sp_helptext	显示默认值、未加密的存储过程、用户定义的存储过程、触发器或视图的实际文本

　　调用存储过程：exec 过程名 [参数]

　　　　如果执行存储过程的语句是批处理中的第一个语句，则可以不指定exec关键字

20.无参数存储过程

create proc[EDURE] 存储过程名
    @参数1 数据类型=默认值 output,
    ......
    @参数n 数据类型=默认值 output
as
    SQL语句
go

　　参数：参数可选、分输入输出、输入参数允许有默认值

use SMDB
go
if exists(select * from sysobjects where name='usp_QueryScore')
drop proc usp_QueryScore
go
create proc usp_QueryScore
as
    select ID=Students.StudentId,姓名=StudentName,班级=ClassName,C#=CSharp,SQL=SQLServerDB,
        总分=(CSHarp+SQLServerDB) from Students
        inner join StudentClass on StudentClass.ClassId=Students.ClassId
        inner join ScoreList on ScoreList.StudentId=Students.StudentId
        order by 总分 DESC

    select 班级=ClassName,C#平均分=AVG(CSharp),SQL平均分=AVG(SQLServerDB)
    from Students
    inner join StudentClass on StudentClass.ClassId=Students.ClassId
    inner join ScoreList on ScoreList.StudentId=Students.StudentId
    group by ClassName order by ClassName
    --group by排序的内容必须出现在select之后才可以被引用

    select StudentClass.ClassId,C#平均分=AVG(CSharp),SQL平均分=AVG(SQLServerDB)
    from Students
    inner join StudentClass on StudentClass.ClassId=Students.ClassId
    inner join ScoreList on ScoreList.StudentId=Students.StudentId
    group by StudentClass.ClassId order by StudentClass.ClassId

    select StudentClass.ClassId,C#平均分=AVG(CSharp),SQL平均分=AVG(SQLServerDB)
    into #ScoreTemp
    from Students
    inner join StudentClass on StudentClass.ClassId=Students.ClassId
    inner join ScoreList on ScoreList.StudentId=Students.StudentId
    group by StudentClass.ClassId order by StudentClass.ClassId
    --将临时表和班级表关联查询
    select ClassName,C#平均分,SQL平均分 from #ScoreTemp
    inner join  StudentClass on StudentClass.ClassId=#ScoreTemp.ClassId
go

exec usp_QueryScore

 21.带输入参数存储过程

use SMDB
go
if exists(select * from sysobjects where name='usp_QueryScore')
drop procedure usp_QueryScore
go 
--创建带参数的存储过程
create proc usp_QueryScore
@CSharp_Min int=60,     --默认参数输入
@CSharp_Max int=80
as
    select Students.StudentId,StudentName,CSharp,SQLServerDB 
    from Students
    inner join ScoreList on Students.StudentId=ScoreList.StudentId
    where CSharp>@CSharp_Min and CSharp<@CSharp_Max
go

select * from ScoreList
--调用带参数的存储过程
exec usp_QueryScore 65,85                             --默认要和定义的参数一一对应
exec usp_QueryScore @CSharp_Max=80,@CSharp_Min=60     --也可以不一一对应但要声明参数名称
exec usp_QueryScore                    --两个参数都是用默认参数
exec usp_QueryScore 65                --只写一个参数，@CSharp_Min=65,C@Sharp_Max默认
exec usp_QueryScore dsefault,90        --第一个参数默认，@CSharp_Max为90
exec usp_QueryScore @CSharp_Min=70  --第一个参数为70，第二个参数默认

22.带输入输出存储过程

use SMDB
go
if exists(select * from sysobjects where name='usp_QueryScore')
drop procedure usp_QueryScore
go 
--创建带参数的存储过程
create proc usp_QueryScore
@AbsentCount int output,  --缺考总人数
@FailedCount int output,  --不及格总人数
@CSharp_Min int=60,     --默认参数输入
@CSharp_Max int=80
as
    select Students.StudentId,StudentName,CSharp,SQLServerDB 
    from Students
    inner join ScoreList on Students.StudentId=ScoreList.StudentId
    where CSharp>@CSharp_Min and CSharp<@CSharp_Max
    --输出参数要在SQL语句中赋值
    select @AbsentCount=count(*) from Students        --查询缺考总人数
        where StudentId not in (select StudentId from ScoreList)
    select @FailedCount=count(*) from ScoreList where CSharp<@CSharp_Min --查询不及格总人数
go

--调用带输出参数的存储过程
declare @Absent int,@Failed int  --首先定义输出参数
exec usp_QueryScore @Absent output,@Failed output,@CSharp_Min=70,@CSharp_Max=99
select 缺考总人数=@Absent,不及格总数=@Failed

 23.事务

　　23.1事务的概念：

1. 事务是作为单个逻辑工作单元执行的一系列操作
2. 多个操作作为一个整体向系统提交，要么都执行、要么都不执行
3. 事务是一个不可分割的工作逻辑单元
4. 通俗讲，如果一个事务中包括两条语句，如果第一条语句执行成功，第二条语句执行失败，会重新撤销第一条语句所执行的结果

　   23.2事务的四个属性

1. 原子性：事务是一个完成的操作，事务的各部操作是不可分的，要么都执行，要么都不执行
2. 一致性：当事务完成时，数据必须都处于一致状态
3. 隔离性：并发事务之间彼此隔离、独立，它不应以任何方式依赖于或影响其他事务
4. 永久性：事务完成后，它对数据库的修改被永久保存

　　23.3事务分类

1. 显式事务：用begin transaction明确指定事务的开始，是最常用的事务类型
2. 隐式事务：通过设置set implicit_transactions on语句，将隐性事务模式设置为打开；其后的T-SQL语句自动启动一个新事务，提交或回滚一个事务后，下一个T-SQL语句又将启动一个新事务
3. 自动提交事务：SQL Server的默认模式，每条单独的T-SQL语句视为一个事务 

　　23.4使用SQL语句管理事务的基本步骤

1. 开始事务：begin transaction
2. 提交事务：commit transaction
3. 回滚（撤销）事务：rollback transaction
4. 一旦事务提交或回滚，则事务结束
5. 事务处理中的关键问题主要是对insert、update、delete语句实时跟踪

use StudentManager
go
select * from CardAccount
go
declare @errorSum int  --定义变量，用于累计事务执行中的错误
set @errorSum=0   --初始化为0，代表没有错误
begin transaction
    begin
        --转出
        update CardAccount set CurrentMoney=CurrentMoney-1000 where StudentId=100001
        set @errorSum=@errorSum+@@ERROR
        --转入
        update CardAccount set CurrentMoney=CurrentMoney+1000 where StudentId=100002
        set @errorSum=@errorSum+@@ERROR
        if(@errorSum=0)
            commit transaction
        else
            rollback transaction
    end
go
select * from CardAccount
go

　　23.5判断某条语句执行是否出错的方法

1. 使用全局变量@@ERROR
2. @@ERROR只判断当前一条T-SQL语句执行是否有错
3. 为了判断事务中所有T-SQL语句是否有错，可以对错误进行累计
4. set @errorSum=@errorSum+@@error

use StudentManager
go
if exists(select * from sysobjects where name='usp_TransferAccounts')
drop proc usp_TransferAccounts
go
create proc usp_TransferAccounts
@intputAccount int,  --转入账户
@outputAccount int,  --转出账户
@transferMoney int --交易金额
as
    declare @errorSum int  --定义变量，用于累计事务执行中的错误
    set @errorSum=0   --初始化为0，代表没有错误
    begin transaction
        begin
            --转出
            update CardAccount set CurrentMoney=CurrentMoney-@transferMoney 
                where StudentId=@outputAccount
            set @errorSum=@errorSum+@@ERROR
            --转入
            update CardAccount set CurrentMoney=CurrentMoney+@transferMoney 
                where StudentId=@intputAccount
            set @errorSum=@errorSum+@@ERROR
            if(@errorSum=0)
                commit transaction
            else
                rollback transaction
        end
go
--测试成功的转换
select * from CardAccount 
exec usp_TransferAccounts 100002,100001,100
select * from CardAccount
--测试失败的转换
exec usp_TransferAccounts 100002,100001,1000
select * from CardAccount

 24.索引

　　添加的索引越多，占用的存储空间越多。每插入、删除、修改一条记录，数据库有可能会更改很多。

　　24.1分类

　　　　聚集索引：表中各行的物理顺序与键值的逻辑（索引）顺序相同，每个表只能有一个

1. 1. 主键索引：为表定义一个主键将自动创建主键索引，主键索引是唯一索引的特殊类型
   2. 主键索引要求主键中的每一值是唯一的，并且不能为空

　　　　非聚集索引（nonclustered index ）：非聚集索引指定表的逻辑顺序

1. 1. 数据可以存储在一个位置，索引存储在另一个位置，索引中包含指向数据存储位置的指针
   2. 可以有多个，小于249
   3. 唯一索引：唯一索引不允许两行具有相同的索引值

 25.在ADO.NET中添加事务

        public static int UpdateByTran(List<string> sqlList)
        {
            SqlConnection conn = new SqlConnection(ConnStr);
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = conn;
            try
            {
                conn.Open();
                cmd.Transaction = conn.BeginTransaction();//开启事务
                int result = 0;
                foreach (string sql in sqlList)
                {
                    cmd.CommandText = sql;
                    result += cmd.ExecuteNonQuery();//执行sql语句
                }
                cmd.Transaction.Commit();//提交事务
                return result;
            }
            catch (Exception ex)
            {
                //写入日志
                if (cmd.Transaction != null)
                {
                    cmd.Transaction.Rollback();//回滚事务
                }
                throw new Exception("调用事务更新方法时出现异常:" + ex.Message);
            }
            finally
            {
                if (cmd.Transaction!=null)
                {
                    cmd.Transaction = null;
                }
                conn.Close();
            }
        }

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
namespace DAL
{
    class SQLHelper
    {
        private static string ConnStr = "Server=.;DataBase=StudentManageDB;Uid=sa;Pwd=****";

        /// <summary>
        /// 返回单一结果查询
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static object GetSignalResult(string sql)
        {
            SqlConnection conn = new SqlConnection(ConnStr);
            SqlCommand cmd = new SqlCommand(sql,conn);
            conn.Open();
            object re = cmd.ExecuteScalar();
            conn.Close();
            return re;
        }

        /// <summary>
        /// 更新数据操作（删、增、改）
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static int GetUpdate(string sql)
        {
            SqlConnection conn = new SqlConnection(ConnStr);
            SqlCommand cmd = new SqlCommand(sql,conn);
            conn.Open();
            int re = cmd.ExecuteNonQuery();
            conn.Close();
            return re;
        }

        /// <summary>
        /// 返回一个结果集的查询
        /// </summary>
        /// <param name="sql"></param>
        /// <returns></returns>
        public static SqlDataReader GerReader(string sql)
        {
            SqlConnection conn = new SqlConnection(ConnStr);
            SqlCommand cmd = new SqlCommand(sql, conn);
            conn.Open();
            return cmd.ExecuteReader(CommandBehavior.CloseConnection);
        }

        /// <summary>
        /// 多条sql语句事务的应用
        /// </summary>
        /// <param name="sqlList">多条sql语句</param>
        /// <returns></returns>
        public static int UpdateByTran(List<string> sqlList)
        {
            SqlConnection conn = new SqlConnection(ConnStr);
            SqlCommand cmd = new SqlCommand();
            cmd.Connection = conn;
            try
            {
                conn.Open();
                cmd.Transaction = conn.BeginTransaction();//开启事务
                int result = 0;
                foreach (string sql in sqlList)
                {
                    cmd.CommandText = sql;
                    result += cmd.ExecuteNonQuery();//执行sql语句
                }
                cmd.Transaction.Commit();//提交事务
                return result;
            }
            catch (Exception ex)
            {
                //写入日志
                if (cmd.Transaction != null)
                {
                    cmd.Transaction.Rollback();//回滚事务
                }
                throw new Exception("调用事务更新方法时出现异常:" + ex.Message);
            }
            finally
            {
                if (cmd.Transaction!=null)
                {
                    cmd.Transaction = null;
                }
                conn.Close();
            }
        }
    }
}

        public DataTable ExecuteDataTable1(string conStr, string sql, CommandType type, params SqlParameter[] param)
        {
            DataTable dt = new DataTable();
            using (SqlConnection con = new SqlConnection(conStr))
            {
                using (SqlCommand command = new SqlCommand())
                {
                    using (SqlDataAdapter adapter = new SqlDataAdapter(sql, con))
                    {
                        command.Connection = con;
                        command.CommandType = type;
                        command.CommandText = sql;
                        if (!(param == null || param.Length == 0))
                        {
                            foreach (SqlParameter parm in param)
                            {
                                command.Parameters.Add(parm);
                            }
                        }
                        //添加参数
                        adapter.SelectCommand = command;
                        //1.打开链接，如果连接没有打开，则它给你打开；如果打开，就算了
                        //2.去执行sql语句，读取数据库
                        //3.sqlDataReader,把读取到的数据填充到内存表中
                        adapter.Fill(dt);
                    }
                }
            }
            return dt;
        }

26.清空数据库日志

    --MES_DB_Utility修改为自己想要操作的数据库
    --MES_DB_IO_log修改为自己想要操作的数据库日志文件
    USE [master]
    GO
    ALTER DATABASE MES_DB_Utility SET RECOVERY SIMPLE WITH NO_WAIT
    GO
    ALTER DATABASE MES_DB_Utility SET RECOVERY SIMPLE   --简单模式
    GO
    USE MES_DB_Utility
    GO
    DBCC SHRINKFILE (N'MES_DB_IO_log' , 0, TRUNCATEONLY)  --设置压缩后的日志大小为2M，可以自行指定
    GO
    USE [master]
    GO
    ALTER DATABASE MES_DB_Utility SET RECOVERY FULL WITH NO_WAIT
    GO
    ALTER DATABASE MES_DB_Utility SET RECOVERY FULL  --还原为完全模式
    GO 

 27.ADO.NET命令执行方式比较

1. 使用完整的SQL语句：Sql语句编写困难、容易出错；网络传输不安全，很容易发生“注入式攻击”；执行效率低
2. 使用带参数的SQL语句：Sql语句编写容易，网络传输安全，执行效率一般
3. 调用存储过程：不需要编写SQL语句，网络传输非常安全，执行效率非常高

28.一般SQL语句与带参数的SQL语句

        public static int InsertStudent(Student objStu)
        {
            string sql = $@"insert into Students (StudentName,Gender,Birthday,StudentIdNo,Age,PhoneNumber,StudentAddress,ClassId)values 
                      ('{objStu.StudentName}','{objStu.Gender}','{objStu.Birthday}',{objStu.StudentIdNo},{objStu.Age},'{objStu.PhoneNumber}','{objStu.StudentAddress}',{objStu.ClassId})";
            return SQLHelper.GetUpdate(sql);
        }

        public static int GetUpdate(string sql,params SqlParameter[] paras)
        {
            SqlConnection conn = new SqlConnection(ConnStr);
            SqlCommand cmd = new SqlCommand(sql,conn);
            try
            {
                if (paras.Length > 0)
                {
                    cmd.Parameters.AddRange(paras);
                }
                conn.Open();
                int re = cmd.ExecuteNonQuery();
                conn.Close();
                return re;
            }
            catch (Exception ex)
            {
                return -1;
            }
        }

        public static int InsertStudent_Paras(Student objStu)
        {
            string sql = "insert into Students (StudentName,Gender,Birthday,StudentIdNo,Age,PhoneNumber,StudentAddress,ClassId)values"; 
            sql+=" (@StudentName,@Gender,@Birthday,@StudentIdNo,@Age,@PhoneNumber,@StudentAddress,@ClassId)";
            SqlParameter[] paras = new SqlParameter[] {
                new SqlParameter("@Studentname",objStu.StudentName),
                new SqlParameter("@Gender",objStu.Gender),
                new SqlParameter("@Birthday",objStu.Birthday),
                new SqlParameter("@StudentIdNo",objStu.StudentIdNo),
                new SqlParameter("@Age",objStu.Age),
                new SqlParameter("@PhoneNumber",objStu.PhoneNumber),
                new SqlParameter("@StudentAddress",objStu.StudentAddress),
                new SqlParameter("@ClassId",objStu.ClassId)
            };
            return SQLHelper.GetUpdate(sql, paras);
        }

        public static int GetUpdate(string sql,params SqlParameter[] paras)
        {
            SqlConnection conn = new SqlConnection(ConnStr);
            SqlCommand cmd = new SqlCommand(sql,conn);
            try
            {
                if (paras.Length > 0)
                {
                    cmd.Parameters.AddRange(paras);
                }
                conn.Open();
                int re = cmd.ExecuteNonQuery();
                conn.Close();
                return re;
            }
            catch (Exception ex)
            {
                return -1;
            }
        }

 29.ADO.NET调用存储过程

1. 先在服务器端编写需要的存储过程，如果有参数，需要@定义好参数
2. 编写调用存储过程的通用数据访问方法。注意cmd.CommandType=CommandType.StoredProcedure;  //声明是存储过程cmd.CommandText=text;  //指定存储过程的名称cmd.Parameters.AddRange(paras);  //添加输入参数
3. 编写调用存储过程的方法

        /// <summary>
        /// 调用存储过程返回结果集（可以是多条结果集）
        /// </summary>
        /// <param name="procedureName">存储过程名</param>
        /// <param name="paras">参数</param>
        /// <returns></returns>
        public static SqlDataReader GetReader(string procedureName, SqlParameter[] paras)
        {
            SqlConnection conn = new SqlConnection();
            SqlCommand cmd = new SqlCommand();
            try
            {
                conn.Open();
                cmd.Connection = conn;
                cmd.CommandType = CommandType.StoredProcedure;
                cmd.CommandText = procedureName;
                cmd.Parameters.AddRange(paras);
                return cmd.ExecuteReader(CommandBehavior.CloseConnection);
            }
            catch (Exception ex)
            {
                conn.Close();
                throw ex;
            }
        }

        //执行存储过程（多个返回值与多个返回列表）
        public List<StudentExt> GetScoreInfo(string className, out Dictionary<string, string> dicParam, out List<string> absentList)
        {
            //定义输入参数，参数名+参数值
            SqlParameter inputClassName = new SqlParameter("@classname",className);
            inputClassName.Direction = ParameterDirection.Input;
            //定义输出参数，参数名+参数类型
            SqlParameter outStuCount = new SqlParameter("@stuCount", SqlDbType.Int);
            outStuCount.Direction = ParameterDirection.Output;
            SqlParameter outAvgDB = new SqlParameter("@avgDB",SqlDbType.Int);
            outAvgDB.Direction = ParameterDirection.Output;
            //执行查询
            SqlParameter[] paras = new SqlParameter[] { inputClassName,outAvgDB};
            SqlDataReader objReader = SQLHelper.GetReader("usp_ScoreQuery",paras);
            //读取考试成绩列表
            List<StudentExt> scoreList = new List<StudentExt>();
            while (objReader.Read())
            {
                scoreList.Add(new StudentExt()
                {
                    StudentId=objReader["StudentId"].ToString(),
                    Age=Convert.ToInt32(objReader["Age"])
                });
            }
            //读取缺考人员列表
            absentList = new List<string>();
            if (objReader.NextResult())
            {
                while (objReader.Read())
                {
                    absentList.Add(objReader["StudentName"].ToString());
                }
            }
            objReader.Close();
            //当执行完后，输出参数自动的已经赋值啦
            //获取输出参数
            dicParam = new Dictionary<string, string>();
            dicParam["StuCount"] = outStuCount.Value.ToString();
            dicParam["AvgDB"] = outAvgDB.Value.ToString();
            return scoreList;
        }

 30.SQLHelper类中方法的总结

1. 执行格式化的SQL语句（使用占位符）
2. 执行带参数的SQL语句（类似存储过程参数，效率和安全性较高）
3. 执行带参数的存储过程（效率最高，安全性最高）
4. 启动事务执行更新（保证数据的一致性）
5. 项目开发中应按照以上分类编写SQLHelper类中的方法，并在适时场合调用不同的的方法