CREATE TABLE tmp ([USER] NVARCHAR(MAX) )
BULK INSERT tmp FROM N’C:\aaa\数据.txt’

脱机数据库删除后，与联机数据删除不同的一点是，它不会自动删除与数据库关联的mdf,ldf文件，即此时若建立一同名数据库，会因数据库文件已经存大而弹出错误信息

sp_procoption [ @ProcName = ] ‘procedure’
, [ @OptionName = ] ‘option’
, [ @OptionValue = ] ‘value’

备注
启动过程必须位于 master 数据库中，并且不能包含 INPUT 或 OUTPUT 参数。启动时恢复了 master 数据库后，即开始执行存储过程。

参数
[ @ProcName = ] ‘procedure’
为其设置选项的过程的名称。 procedure 的数据类型为 nvarchar(776)，无默认值。

[ @OptionName = ] ‘option’
要设置的选项的名称。option 的唯一值为 startup。

[ @OptionValue = ] ‘value’
指示是将选项设置为开启（true 或 on）还是关闭（false 或 off）。value 的数据类型为 varchar(12)，无默认值。

返回代码值
0（成功）或错误号（失败）

权限
要求具有 sysadmin 固定服务器角色的成员身份。

EXEC GetTableScript 'frmuser'

CREATE PROCEDURE GetTableScript 
@TableName VARCHAR(50)
AS 

--To get table script
declare @Id int, @i int, @i2 int,@Sql varchar(max),@Sql2 varchar(max), @f1 varchar(5), @f2 varchar(5), @f3 varchar(5), @f4 varchar(5), @T varchar(5)
    select @Id=object_id(@TableName), @f1 = char(13) + char(10), @f2 = '    ', @f3=@f1+@f2, @f4=',' + @f3
    
    if not(@Id is null)
    BEGIN
    declare @Data table(Id int identity primary key, D varchar(max) not null, ic int null, re int null, o int not null);
    
    -- Columns
    with c as(
        select c.column_id, Nr = row_number() over(order by c.column_id), Clr=count(*) over(),
            D = quotename(c.name) + ' ' +
                case when s.name = 'sys' or c.is_computed=1 then '' else quotename(s.name) + '.' end +
                case when c.is_computed=1 then '' when s.name = 'sys' then t.Name else quotename(t.name) end +
                case when c.user_type_id!=c.system_type_id or c.is_computed=1 then ''
                    when t.Name in ('xml', 'uniqueidentifier', 'tinyint', 'timestamp', 'time', 'text', 'sysname', 'sql_variant', 'smallmoney', 'smallint', 'smalldatetime', 'ntext', 'money',
                                    'int', 'image', 'hierarchyid', 'geometry', 'geography', 'float', 'datetimeoffset', 'datetime2', 'datetime', 'date', 'bigint', 'bit') then ''
                    when t.Name in('varchar','varbinary', 'real', 'numeric', 'decimal', 'char', 'binary')
                        then '(' + isnull(convert(varchar,nullif(c.max_length,-1)), 'max') + isnull(','+convert(varchar,nullif(c.scale, 0)), '') + ')'
                    when t.Name in('nvarchar','nchar')
                        then '(' + isnull(convert(varchar,nullif(c.max_length,-1) / 2), 'max') + isnull(','+convert(varchar,nullif(c.scale, 0)), '') + ')'
                    else '??'
                    end + 
                case when ic.object_id is not null then ' identity(' + convert(varchar,ic.seed_value) + ',' + convert(varchar,ic.increment_value) + ')' else '' end +
                case when c.is_computed=1 then 'as' + cc.definition when c.is_nullable = 1 then ' null' else ' not null' end +
                case c.is_rowguidcol when 1 then ' rowguidcol' else '' end +
                case when d.object_id is not null then ' default ' + d.definition else  '' end
        from sys.columns c
        inner join sys.types t
        on t.user_type_id = c.user_type_id
        inner join sys.schemas s
        on s.schema_id=t.schema_id
        left outer join sys.computed_columns cc
        on cc.object_id=c.object_id and cc.column_id=c.column_id
        left outer join sys.default_constraints d
        on d.parent_object_id=@id and d.parent_column_id=c.column_id
        left outer join sys.identity_columns ic
        on ic.object_id=c.object_id and ic.column_id=c.column_id
        where c.object_id=@Id
        
    )
        insert into @Data(D, o)
        select '    ' + D + case Nr when Clr then '' else ',' + @f1 end, 0
        from c where NOT D IS NULL 
        order by column_id
    
    -- SubObjects
    set @i=0
    while 1=1
        begin
        select top 1 @i=c.object_id, @T = c.type, @i2=i.index_id
        from sys.objects c 
        left outer join sys.indexes i
        on i.object_id=@Id and i.name=c.name
        where parent_object_id=@Id and c.object_id>@i and c.type not in('D')
        order by c.object_id
        if @@rowcount=0 break
        if @T = 'C' 
            insert into @Data 
            select @f4 + 'check ' + case is_not_for_replication when 1 then 'not for replication ' else '' end + definition, null, null, 10
            from sys.check_constraints where object_id=@i
        else if @T = 'Pk'
            insert into @Data 
            select @f4 + 'primary key' + isnull(' ' + nullif(lower(i.type_desc),'clustered'), ''), @i2, null, 20
            from sys.indexes i
            where i.object_id=@Id and i.index_id=@i2
        else if @T = 'uq'
            insert into @Data values(@f4 + 'unique', @i2, null, 30)
        else if @T = 'f'
            begin
            insert into @Data 
            select @f4 + 'foreign key', -1, @i, 40
            from sys.foreign_keys f
            where f.object_id=@i
            
            insert into @Data 
            select ' references ' + quotename(s.name) + '.' + quotename(o.name), -2, @i, 41
            from sys.foreign_keys f
            inner join sys.objects o
            on o.object_id=f.referenced_object_id
            inner join sys.schemas s
            on s.schema_id=o.schema_id
            where f.object_id=@i
            
            insert into @Data 
            select ' not for replication', -3, @i, 42
            from sys.foreign_keys f
            inner join sys.objects o
            on o.object_id=f.referenced_object_id
            inner join sys.schemas s
            on s.schema_id=o.schema_id
            where f.object_id=@i and f.is_not_for_replication=1
            end
        else
            insert into @Data values(@f4 + 'Unknow SubObject [' + @T + ']', null, null, 99)
        end

    insert into @Data values(@f1+')', null, null, 100)
    
    -- Indexes
    insert into @Data
    select @f1 + 'create ' + case is_unique when 1 then 'unique ' else '' end + lower(s.type_desc) + ' index ' + 'i' + convert(varchar, row_number() over(order by index_id)) + ' on ' + quotename(sc.Name) + '.' + quotename(o.name), index_id, null, 1000
    from sys.indexes s
    inner join sys.objects o
    on o.object_id=s.object_id
    inner join sys.schemas sc
    on sc.schema_id=o.schema_id
    where s.object_id=@Id and is_unique_constraint=0 and is_primary_key=0 and s.type_desc != 'heap'
    
    -- columns
    set @i=0
    while 1=1
        begin
        select top 1 @i=ic from @Data where ic>@i order by ic 
        if @@rowcount=0 break
        select @i2=0, @Sql=null, @Sql2=null
        while 1=1
            begin
            select @i2=index_column_id, 
                @Sql = case c.is_included_column when 1 then @Sql else isnull(@Sql + ', ', '(') + cc.Name + case c.is_descending_key when 1  then ' desc' else '' end end,
                @Sql2 = case c.is_included_column when 0 then @Sql2 else isnull(@Sql2 + ', ', '(') + cc.Name + case c.is_descending_key when 1  then ' desc' else '' end end
            from sys.index_columns c
            inner join sys.columns cc
            on c.column_id=cc.column_id and cc.object_id=c.object_id
            where c.object_id=@Id and index_id=@i and index_column_id>@i2
            order by index_column_id
            if @@rowcount=0 break
            end
        update @Data set D=D+@Sql +')' + isnull(' include' + @Sql2 + ')', '') where ic=@i
        end
        
    -- references
    set @i=0
    while 1=1
        begin
        select top 1 @i=re from @Data where re>@i order by re
        if @@rowcount=0 break
        
        select @i2=0, @Sql=null, @Sql2=null
        while 1=1
            begin
            select @i2=f.constraint_column_id, 
                @Sql = isnull(@Sql + ', ', '(') + c1.Name,
                @Sql2 = isnull(@Sql2 + ', ', '(') + c2.Name
            from sys.foreign_key_columns f
            inner join sys.columns c1
            on c1.column_id=f.parent_column_id and c1.object_id=f.parent_object_id
            inner join sys.columns c2
            on c2.column_id=f.referenced_column_id and c2.object_id=f.referenced_object_id
            where f.constraint_object_id=@i and f.constraint_column_id>@i2
            order by f.constraint_column_id
            if @@rowcount=0 break
            end
        update @Data set D = D + @Sql + ')'  where re=@i and ic=-1
        update @Data set D = D + @Sql2 + ')'  where re=@i and ic=-2
        end;
    
    -- Render
    with x as(
        select id=d.id-1, D=d.D + isnull(d2.D,'')
        from @Data d
        left outer join @Data d2
        on d.re=d2.re and d2.o=42
        where d.o=41
        
    )
    update @Data
        set D=d.D+x.D
    from @Data d
    inner join x
    on x.id=d.id
    
    delete @Data where o in(41, 42)
    
    select @Sql = 'create table ' + quotename(s.name) + '.' + quotename(o.name) + '(' + @f1
    from sys.objects o
    inner join sys.schemas s
    on o.schema_id = s.schema_id
    where o.object_id=@Id
    
    set @i=0
    while 1=1
        begin
        select top 1 @I=Id, @Sql = @Sql + D from @Data order by o, case when o=0 then right('0000' + convert(varchar,id),5)  else D end, id
        if @@rowcount=0 break
        delete @Data where id=@i
        end
    END
    SELECT @Sql

引自：http://www.cnblogs.com/unruledboy/archive/2011/12/05/SQLMon2.html

视图创建之后，若表结构发生改变，此时视图是不改变的，需要刷新视图才可。
exec sp_refreshview ‘VR_bswGoods’

复制：将数据传输到其他服务器上存储，做备份。
镜像：主服务器数据库挂了，另一台自动成为主服务器运行，
日志：可控制的镜像。
集群：主服务器挂了，另一台自动成为主服务器运行，并不仅限于数据库。

明细：引自http://hi.baidu.com/jaimy_jie/blog/item/6e099ed52f42a4d250da4b24.html

一, 数据库复制

SQL Server 2008数据库复制是通过发布/订阅的机制进行多台服务器之间的数据同步，我们把它用于数据库的同步备份。这里的同步备份指的是备份服务器与主服务器进行 实时数据同步，正常情况下只使用主数据库服务器，备份服务器只在主服务器出现故障时投入使用。它是一种优于文件备份的数据库备份解决方案。

SQL Server的复制分为种：

1. 快照发布:

发布服务器按预定的时间间隔向订阅服务器发送已发布数据的快照。每隔一段时间将订阅数据库中的相应表中的数据全部删除，然后将自己相应表中的全部插到订阅数据库中

使用快照复制本身是最合适的：
1）很少更改数据。
2）在一段时间内允许具有相对发布服务器已过时的数据副本。
3）复制少量数据。
4）在短期内出现大量更改。

在数据更改量很大，但很少发生更改时，快照复制是最合适的。 例如，如果某销售组织维护一个产品价格列表且这些价格每年要在固定时间进行一两次完全更新，那么建议在数据更改后复制完整的数据快照。 对于给定的某些类型的数据，更频繁的快照可能也比较适合。 例如，如果一天中在发布服务器上更新相对小的表，但可以接受一定的滞后时间，则可以在夜间以快照形式传递更改。

发布服务器上快照复制的连续开销低于事务复制的开销，因为不用跟踪增量更改。 但是，如果要复制的数据集非常大，那么若要生成和应用快照，将需要使用大量资源。 评估是否使用快照复制时，需要考虑整个数据集的大小以及数据的更改频率。

2. 事务发布:

在订阅服务器收到已发布数据的初始快照后，发布服务器将事务流式传输到订阅服务器。

事务复制通常从发布数据库对象和数据的快照开始。 创建了初始快照后，接着在发布服务器上所做的数据更改和架构修改通常在修改发生时（几乎实时）便传递给订阅服务器。 数据更改将按照其在发布服务器上发生的顺序和事务边界应用于订阅服务器，因此，在发布内部可以保证事务的一致性。

以下各种情况下适合采用事务复制：
1). 希望发生增量更改时将其传播到订阅服务器。
2). 从发布服务器上发生更改，至更改到达订阅服务器，应用程序需要这两者之间的滞后时间较短。
3). 应用程序需要访问中间数据状态。 例如，如果某一行更改了五次，事务复制将允许应用程序响应每次更改（例如，激发触发器），而不只是响应该行最终的数据更改。
4).发布服务器有大量的插入、更新和删除活动。
5).发布服务器或订阅服务器不是 SQL Server 数据库（例如，Oracle）。

默认情况下，事务发布的订阅服务器应视为只读，因为更改将不会传播回发布服务器。 但是，事务复制确实提供了允许在订阅服务器上进行更新的选项

3. 具有可更新订阅的事务发布:

在 SQL Server 订阅服务器收到已发布数据的初始快照后，发布服务器将事务流式传输到订阅服务器。来自订阅服务器的事务被应用于发布服务器。

4. 合并发布:

在订阅服务器收到已发布数据的初始快照后，发布服务器和订阅服务器可以独立更新已发布数据。更改会定期合并。Microsoft SQL Server Compact Edition 只能订阅合并发布。

与事务复制相同，合并复制通常也是从发布数据库对象和数据的快照开始， 并且用触发器跟踪在发布服务器和订阅服务器上所做的后续数据更改和架构修改。 订阅服务器在连接到网络时将与发布服务器进行同步，并交换自上次同步以来发布服务器和订阅服务器之间发生更改的所有行。

合并复制通常用于服务器到客户端的环境中。 合并复制适用于下列各种情况：
1). 多个订阅服务器可能会在不同时间更新同一数据，并将其更改传播到发布服务器和其他订阅服务器。
2). 订阅服务器需要接收数据，脱机更改数据，并在以后与发布服务器和其他订阅服务器同步更改。
3). 每个订阅服务器都需要不同的数据分区。
4). 可能会发生冲突，并且在冲突发生时，您需要具有检测和解决冲突的能力。
5). 应用程序需要最终的数据更改结果，而不是访问中间数据状态。 例如，如果在订阅服务器与发布服务器进行同步之前，订阅服务器上的行更改了五次，则该行在发布服务器上仅更改一次来反映最终数据更改（也就是第五次更改的值）。

合并复制允许不同站点自主工作，并在以后将更新合并成一个统一的结果。 由于更新是在多个节点上进行的，同一数据可能由发布服务器和多个订阅服务器进行了更新。 因此，在合并更新时可能会产生冲突，合并复制提供了多种处理冲突的方法

复制的缺点： 表有主键，而且表结构日后不能更改，如果架构稳定也是不错的，如果有很多张表那就比较麻烦了

复制方法及过程：

http://www.cnblogs.com/dudu/archive/2010/08/26/1808540.html

http://www.cnblogs.com/killkill/archive/2009/07/17/1525733.html

http://dufei.blog.51cto.com/382644/84645

http://www.cnblogs.com/wangdong/archive/2008/10/24/1318740.html

二，数据库镜像：

数据库镜像：

优点是系统能自动发现主服务器故障，并且自动切换至镜像服务器。

缺点是配置复杂，镜像数据库中的数据不可见（在SQL Server Management Studio中，只能看到镜像数据库处于镜像状态，无法进行任何数据库操作，最简单的查询也不行。想眼见为实，看看镜像数据库中的数据是否正确都不行。只 有将镜像数据库切换主数据库才可见）

相对于日志传送，数据库镜像显然更高一级。在最简单的形式下，它其实与日志传送的工作原理相似，但是生产服务器发送事务到镜像服务器的频率要高得多，这意味着更新速度也要快很多。

　　对于数据库镜像来说，故障转移功能也是需要手动完成。但是你可以添加第三个SQL Server，称为witness。Witness可以作为一个普通的SQL Server，但是一直留意着其它两个镜像服务器。当主镜像发生故障，witness可以让第二个镜像接管操作，类似一种自动的故障转移。

　　在故障转移时，任何进行中的客户端事务都将重新启动，而由于在这一过程中仍然存在着延迟，镜像服务器也不能保证百分之百不丢失数据。

三，数据库日志传输：

作为高可用性的最低级形式，日志传送(log shipping)本质上是SQL Server复制功能的一种延伸

允许解决方案提供商创建多个数据库副本。日志传输能够将次数据库日志副本同步发送到SQL Server实例上。然后这些日志会在次服务器上重放，从而保持数据库副本是最新的。

　　有一些解决方案提供商使用日志传输作为克服数据库镜像缺点的方法。数据库镜像是很好的技术，但是它只允许我们实现一个数据库副本。镜像可以接近实时的方式进行，所以数据库修改可以快速地写到次数据库上。如果客户数据库损坏或数据库记录意外删除，那么这可能会造成问题。

　　日志传输有两个主要的优点。首先，解决方案提供商能够实现一种延迟，这样日志就不会即时重放。这是很重要的，因为如果主(或镜像)数据库出现问题，日志可以在重放之前拦截，因此可以防止问题扩散。

　　日志传输第二个主要的优点是它支持实现多个数据库副本。有一些单位使用日志传输作为在备份数据中心维护数据库副本的方法，这能够防止主数据中心出现问题时发生数据丢失。

　　 虽然日志传输通过是作为数据库镜像的补充措施，但是它是一种独立的技术，它可以不依赖于镜像技术而独立使用。

http://www.searchdatabase.com.cn/showcontent_11708.htm

四，故障转移集群

集群技术是微软可用性的最高级形式，它需要你设置一个Windows集群。

　　在集群中并不会涉及传输以及镜像，取而代之，两台或更多的电脑将会彼此连接在一个共享的外部存储器中，通常是存储区域网络(SAN)。数据库文件就存放在这个共享存储器上，同样设置的SQL Server实例都运行在集群节点上。

　　集群中的所有节点中，实际上只有一个节点是一直处在活动状态的，如果这个节点发生故障，其它的节点将启动相应的SQL Server实例，并连接共享存储器的数据文件。而整个故障转移过程往往只有几秒钟时间，对于任何给定的SQL Server实例，Windows集群技术都可以确保客户端始终注视活动的节点。

　　集群技术非常复杂，但它是实现高可用的最高效技术。与前面介绍的两个功能相比，集群依赖于一个单一的数据库文件集。如果这些文件损坏了，故障转移也不能起作用了，因为故障转移的实例同损坏的文件是一样的。而使用镜像与日志传送，你可以对文件进行实时拷贝，因此不必担心文件损坏的问题。SQL Server中，文件遭到损坏的情况很少发生，因此我认为集群应该还是一个不错的选择。

缺点的。其中一个重要的问题是故障恢复的实现是非常昂贵的。Microsoft只在那些通过Windows Server认证的硬件上才支持故障恢复。 另一个问题是它要求使用共享存储

go N :执行批语句N次

Create Table #Temp(SerialNo int identity Primary key, Product varchar(500))
go
 
Declare @Product varchar(500)
SET @Product='Mouse'
insert into #Temp(Product)
select @Product

GO 20

select * from #Temp
drop Table #Temp

磁盘负责三方面，一个将数据写入到日志文件ldf中，然后在check point后写入到mdf, 接着就是大量的读操作。
先写入ldf,是因为sql server的预写日志机制引起的，此机制保证了数据在写入到mdf中前，一定会在ldf中保留一份，这样以后恢复等操作都可进行，故可以说，影响写性能的主要是写入到ldf中的操作。磁盘一边负责随机取数据，一边负责写入数据，磁头转来变去，性能低下，而将ldf文件放在不同的磁盘中，就独立了写操作。
注意：磁盘应是物理上的。

Other logical drive will not benefit because ultimately, it’s the same drive controller and the same physical disc. Hence, if the heads are busy doing random reads for a logical drive D, they won’t be able to perform serial writes on logical drive E on the same physical drive.

Hence, the log should be given the priviledge of it’s own separate physical drive.
引自：
Performance Best practice – Transaction log must on a different drive. But WHY?
Write-Ahead Transaction Log

当 SET NOCOUNT 为 ON 时，不返回计数（表示受 Transact-SQL 语句影响的行数）。当 SET NOCOUNT 为 OFF 时，返回计数。

即使当 SET NOCOUNT 为 ON 时，也更新 @@ROWCOUNT 函数。

当 SET NOCOUNT 为 ON 时，将不向客户端发送存储过程中每个语句的 DONE_IN_PROC 消息。使用由 SQL Server 2005 提供的实用工具执行查询时，其结果会防止在 Transact-SQL 语句（例如 SELECT、INSERT、UPDATE 和 DELETE）的末尾显示 nn rows affected。

如果存储过程中包含的一些语句并不返回许多实际数据，则该设置由于大量减少了网络流量，因此可显著提高性能。

SET NOCOUNT 设置是在执行或运行时设置，而不是在分析时设置。

1, INFORMATION_SCHEMA.COLUMNS :存储列定义，包含列类型，长度等信息。
2，INFORMATION_SCHEMA.PARAMETERS：存储过程参数信息。
如：查询行长度：
select
c.table_name,
count(*) columns,
sum(
case data_type
when 'binary' then character_maximum_length
when 'varbinary' then character_maximum_length
when 'char' then character_maximum_length
when 'varchar' then character_maximum_length
when 'nchar' then character_maximum_length
when 'nvarchar' then character_maximum_length
when 'bigint' then 8
when 'int' then 4
when 'uniqueidentifier' then 16
when 'datetime' then 8
when 'bit' then 1
when 'image' then 16
when 'text' then 16
when 'ntext' then 16
end) as avgLen
 from INFORMATION_SCHEMA.COLUMNS c join INFORMATION_SCHEMA.Tables t
ON c.Table_Schema=t.Table_Schema AND c.Table_Name=t.Table_Name
WHERE t.TABLE_TYPE='BASE TABLE' AND c.TABLE_NAME NOT IN('dtproperties','sysdiagrams')
--AND table_name like '%log'
group by c.table_name
order by avgLen desc
go

聚集索引叶级别除了保持键值外，还包含所有数据
非聚集索引叶级别只有需要的键值及书签，以“文件号：页号：槽号”的格式定位
查看索引存储：
–打开3604，信息发送到控制台
DBCC TRACEON(3604)
–查看表索引对应的页数明细
DBCC IND (‘brm_lvjian_new’, ‘frmuser’, -1);
–查看页上的数据信息
DBCC PAGE (brm_lvjian_new, 1, 586958, 1);
在Memory Dump下存储着信息。

不过非聚集索引并不一定比聚集索引快，但where条件，select字段都是复合索引字段时，因索引
空间较小，比件聚集索引查找快一些。
如：在frmUser表中DepartmentID上建立非聚集索引
执行：
SELECT departmentid
FROM frmuser
WHERE DepartmentId = 4

SELECT *
FROM frmuser
WHERE DepartmentId = 4

发现前者通过索引查找一步到位，而后者在索引查找后，因还要取其它值，故还要根据索引页键值中的引用，去数据页取值
这提示：SELECT中的字段少一些速度会更快，一是若字段在一索引内，就避免了去数据页的检索，二是避免了大量数据的I/O操作。
复合索引与对字段分别建索引的区别：
1，复合索引整体空间比分别建索引要小。
2，若查询语句对索引内字段查询，复合索引直接得到位置，而分别建索引需要分别查出再连接
并且当SELECT字段也在索引内时，复合索引会直接得出，而分另建索引则需要去数据页重新取。