博客园_灵感之源

开源项目：高级SQL Server监控、性能图、分析与优化、版本控制

2011-12-05T01:48:00Z

这是一个相当高级的SQL Server监控工具，全面监控SQL Server的活动与性能，分析性能瓶颈，给出优化建议。

red-gate有一个在线的数据库监控工具，不过那个商业的东西价钱不便宜。我写的这个平民版，开源，功能上有颇多的差异（各有长短）。

项目在Codeplex上开源：http://sqlmon.codeplex.com/

在Codeproject上有英文介绍：http://www.codeproject.com/KB/database/sqlmonitor.aspx

介绍

是否想过：“SQL Server为什么那么慢？”，“为什么CPU占用那么高？”，“到底哪里死锁了？”，“为什么数据库那么大？”，“怎样才可以查看我的存储过程和函数的历史版本？”，“可以让我的SQL Server跑得更快吗？”。

你的答案就在这里;-)

到底能干嘛

监控SQL Server的活动：进程、任务，详细查看当前执行的语句与实际变量值，终止进程
IO/CPU/网络等性能趋势图
函数/存储过程等的版本控制，这在商业软件中也没有（如果你知道，告诉我）
对象浏览器：服务器、数据库、表、视图、函数、存储过程等
数据库管理：收缩、日志清除、备份、恢复等
在整个数据库中搜索对象/脚本内容，这在SQL Server 2012中也无法做到
自动显示所有对象的脚本，如表、视图、函数、存储过程等

概览

在上图中，我们可以看见表的create脚本。如果你选择其它对象，如函数、存储过程等，一样会显示相应的脚本。

在对象列表中，如果是数据表，显示表的占用空间（包括索引）、记录数等。

这些在SQL Server 2012中都没有。

获取数据库信息

SELECT DB_NAME(database_id) AS DatabaseName, Name AS Logical_Name, Physical_Name, CAST(size AS decimal(30,0))*8 AS Size, state FROM sys.master_files WHERE DB_NAME(database_id) = 'YOUR_DATABASE_NAME'

对象/脚本搜索

--search in script
Select s.name, s.create_date AS CreateDate, s.modify_date AS ModifyDate, s.type, c.text from syscomments c left join sys.objects s on c.id = s.object_id where [Text] like '%YOUR_QUERY_HERE%'

--search in jobs
SELECT job_id, name, date_created AS CreateDate, date_modified AS ModifyDate, 'Job' AS type FROM msdb.dbo.sysjobs

获取表结构

--To get table names and records
SELECT
    [TableName] = so.name,
    [RowCount] = MAX(si.rows)
FROM
    sysobjects so,
    sysindexes si
WHERE
    so.xtype = 'U'
    AND
    si.id = OBJECT_ID(so.name)
GROUP BY
    so.name
--To get table used space
EXEC sp_spaceused 'TABLE_NAME'
--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('YOUR_TABLE_NAME_HERE'), @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

性能趋势图

在上图中，我们可以看见SQL Server历史/当前的IO/CPU/网络信息都在趋势图中显示。

这些数据来自几个系统变量：

@@cpu_busy
@@io_busy
@@idle
@@pack_received
@@pack_sent
@@connections
@@packet_errors
@@total_read
@@total_write
@@total_errors

以下是相应的SQL：

declare @now         datetime
declare @cpu_busy     int
declare @io_busy    int
declare @idle        int
declare @pack_received    int
declare @pack_sent    int
declare @pack_errors    int
declare @connections    int
declare @total_read    int
declare @total_write    int
declare @total_errors    int

declare @oldcpu_busy     int    /* used to see if DataServer has been rebooted */
declare @interval    int
declare @mspertick    int    /* milliseconds per tick */

/*
**  Set @mspertick.  This is just used to make the numbers easier to handle
**  and avoid overflow.
*/
select @mspertick = convert(int, @@timeticks / 1000.0)

/*
**  Get current monitor values.
*/
select
    @now = getdate(),
    @cpu_busy = @@cpu_busy,
    @io_busy = @@io_busy,
    @idle = @@idle,
    @pack_received = @@pack_received,
    @pack_sent = @@pack_sent,
    @connections = @@connections,
    @pack_errors = @@packet_errors,
    @total_read = @@total_read,
    @total_write = @@total_write,
    @total_errors = @@total_errors

/*
**  Check to see if DataServer has been rebooted.  If it has then the
**  value of @@cpu_busy will be less than the value of spt_monitor.cpu_busy.
**  If it has update spt_monitor.
*/
select @oldcpu_busy = cpu_busy
    from master.dbo.spt_monitor
if @oldcpu_busy > @cpu_busy
begin
    update master.dbo.spt_monitor
        set
            lastrun = @now,
            cpu_busy = @cpu_busy,
            io_busy = @io_busy,
            idle = @idle,
            pack_received = @pack_received,
            pack_sent = @pack_sent,
            connections = @connections,
            pack_errors = @pack_errors,
            total_read = @total_read,
            total_write = @total_write,
            total_errors = @total_errors
end

/*
**  Now print out old and new monitor values.
*/
set nocount on
select @interval = datediff(ss, lastrun, @now)
    from master.dbo.spt_monitor
/* To prevent a divide by zero error when run for the first
** time after boot up
*/
if @interval = 0
    select @interval = 1
select last_run = lastrun, current_run = @now, seconds = @interval,
    cpu_busy_total = convert(int, ((@cpu_busy * @mspertick) / 1000)),
    cpu_busy_current = convert(int, (((@cpu_busy - cpu_busy)
        * @mspertick) / 1000)),
    cpu_busy_percentage = convert(int, ((((@cpu_busy - cpu_busy)
        * @mspertick) / 1000) * 100) / @interval),
    io_busy_total = convert(int, ((@io_busy * @mspertick) / 1000)),
    io_busy_current = convert(int, (((@io_busy - io_busy)
        * @mspertick) / 1000)),
    io_busy_percentage = convert(int, ((((@io_busy - io_busy)
        * @mspertick) / 1000) * 100) / @interval),
    idle_total = convert(int, ((convert(bigint,@idle) * @mspertick) / 1000)),
    idle_current = convert(int, (((@idle - idle)
        * @mspertick) / 1000)),
    idle_percentage = convert(int, ((((@idle - idle)
        * @mspertick) / 1000) * 100) / @interval),
    packets_received_total = @pack_received,
    packets_received_current = @pack_received - pack_received,
    packets_sent_total = @pack_sent,
    packets_sent_current = @pack_sent - pack_sent,
    packet_errors_total = @pack_errors,
    packet_errors_current = @pack_errors - pack_errors,
    total_read = @total_read,
    current_read = @total_read - total_read,
    total_write = @total_write,
    current_write =    @total_write - total_write,
    total_errors = @total_errors,
    current_errors = @total_errors - total_errors,
    connections_total = @connections,
    connections_current = @connections - connections
from master.dbo.spt_monitor

/*
**  Now update spt_monitor
*/
update master.dbo.spt_monitor
    set
        lastrun = @now,
        cpu_busy = @cpu_busy,
        io_busy = @io_busy,
        idle = @idle,
        pack_received = @pack_received,
        pack_sent = @pack_sent,
        connections = @connections,
        pack_errors = @pack_errors,
        total_read = @total_read,
        total_write = @total_write,
        total_errors = @total_errors

版本控制

数据库开发人员总在想，每次修改了函数/存储过程，我们都得自己做备份，用以历史参考，当发现错误的时候，可以回滚。在SQL Monitor里面，这个是全自动的。

版本控制的思想来自这里：http://www.sqlteam.com/article/using-ddl-triggers-in-sql-server-2005-to-capture-schema-changes

原理就是用数据库DDL触发器记录每个DDL操作，自增版本，并存储到一个表中。

关键代码

SET ANSI_NULLS OFF
GO
SET QUOTED_IDENTIFIER OFF
GO
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
IF NOT EXISTS (SELECT * FROM sys.objects WHERE object_id = OBJECT_ID(N'[dbo].[VERSION_CONTROL_TABLE]') AND type in (N'U'))
BEGIN
CREATE TABLE [dbo].[{0}](
    [ID] [bigint] IDENTITY(1,1) NOT NULL,
    [databasename] [varchar](256) NULL,
    [eventtype] [varchar](50) NULL,
    [objectname] [varchar](256) NULL,
    [objecttype] [varchar](25) NULL,
    [sqlcommand] [nvarchar](max) NULL,
    [loginname] [varchar](256) NULL,
    [hostname] [varchar](256) NULL,
    [PostTime] [datetime] NULL,
    [Version] [int] NOT NULL,
CONSTRAINT [PK_VERSION_CONTROL_TABLE] PRIMARY KEY CLUSTERED
(
    [ID] ASC
)WITH (IGNORE_DUP_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
END

GO

SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO

CREATE TRIGGER [TRG_VERSION_CONTROL_TABLE}]
ON DATABASE
FOR CREATE_PROCEDURE, ALTER_PROCEDURE, DROP_PROCEDURE,
CREATE_TABLE, ALTER_TABLE, DROP_TABLE,
CREATE_FUNCTION, ALTER_FUNCTION, DROP_FUNCTION,
CREATE_TRIGGER, ALTER_TRIGGER, DROP_TRIGGER,
CREATE_VIEW, ALTER_VIEW, DROP_VIEW,
CREATE_INDEX, ALTER_INDEX, DROP_INDEX

AS

SET NOCOUNT ON

DECLARE @CurrentVersion int
DECLARE @CurrentID int
DECLARE @DatabaseName varchar(256)
DECLARE @ObjectName varchar(256)
DECLARE @data XML

SET @data = EVENTDATA()

INSERT INTO dbo.VERSION_CONTROL_TABLE(databasename, eventtype,objectname, objecttype, sqlcommand, loginname,Hostname,PostTime, Version)
VALUES(
@data.value('(/EVENT_INSTANCE/DatabaseName)[1]', 'varchar(256)'),
@data.value('(/EVENT_INSTANCE/EventType)[1]', 'varchar(50)'),  -- value is case-sensitive
@data.value('(/EVENT_INSTANCE/ObjectName)[1]', 'varchar(256)'),
@data.value('(/EVENT_INSTANCE/ObjectType)[1]', 'varchar(25)'),
@data.value('(/EVENT_INSTANCE/TSQLCommand)[1]', 'varchar(max)'),
@data.value('(/EVENT_INSTANCE/LoginName)[1]', 'varchar(256)'),
HOST_NAME(),
GETDATE(),
0
)

SET @CurrentID = IDENT_CURRENT('VERSION_CONTROL_TABLE')
SELECT @DatabaseName = databasename, @ObjectName = objectname FROM VERSION_CONTROL_TABLE WHERE ID = @CurrentID
IF (@DatabaseName IS NOT NULL AND @ObjectName IS NOT NULL)
BEGIN
    SELECT @CurrentVersion = MAX(Version) FROM VERSION_CONTROL_TABLE WHERE databasename = @DatabaseName AND objectname = @ObjectName
    UPDATE VERSION_CONTROL_TABLE SET Version = ISNULL(@CurrentVersion, 0) + 1 WHERE ID = @CurrentID
END
GO
ENABLE TRIGGER [TRG_VERSION_CONTROL_TABLE] ON DATABASE

SQL Monitor会全自动给你的所有脚本修改做版本记录。你可以随时查看在什么时候哪个机器用什么身份修改了哪个对象的脚本。

SQL Monitor内置版本比较，你可以清楚知道不同的版本的差异。

活动监控

上图清晰显示所有系统的活动进程，每个进程当前执行什么语句。

获取进程列表

--To get jobs
SELECT job_id AS spid, name AS program_name, 0 AS dbid, 0 AS cpu, 0 AS physical_io, NULL AS login_time, NULL AS last_batch_begin, NULL AS last_batch_end, NULL AS status, NULL AS hostname, NULL AS hostprocess, NULL AS cmd, NULL AS loginname FROM msdb.dbo.sysjobs

分析

这是商业级的数据与性能分析，SQL Monitor自动给你的系统、数据库、数据表、索引等进行分析。

基本原理是首先利用master.sys.xp_fixeddrives获取磁盘的剩余空间，然后：

//database & disk free space
        var databases = GetDatabasesInfo();
        var files = new List<tuple<bool, />>();
        databases.AsEnumerable().ForEach(d =>
        {
            var database = GetDatabaseInfo(d["name"].ToString());
            database.AsEnumerable().ForEach(f =>
            {
                files.Add(new Tuple<bool, />(Convert.ToInt32(f["type"]) == 1, f["physical_name"].ToString(), Convert.ToInt64(Convert.ToDecimal(f["Size"]) / Size1K)));
            }
            );
        });
        var spaces = new Dictionary<string, />>();
        //MB free
        var driveSpaces = Query("EXEC master.sys.xp_fixeddrives");
        driveSpaces.AsEnumerable().ForEach(s =>
        {
            //could not use name but rather index, because the column name will change according to locale
            spaces.Add(s[0].ToString(), new KeyValue<long, />(Convert.ToInt64(s[1]), 0));
        });
        files.ForEach(f =>
        {
            //maybe some access issues
            try
            {
                var drive = f.Item2.Substring(0, 1);
                if (spaces.ContainsKey(drive))
                {
                    spaces[drive].Value += f.Item3;
                }
            }
            catch (Exception)
            {
                //mmmm.....what can we do, mate?
            }
        });
        spaces.ForEach(s =>
        {
            if (s.Value.Key < s.Value.Value / 100 * Settings.Instance.DatabaseDiskFreeSpaceRatio)
            {
                analysisResult.Add(new AnalysisResult { ResultType = AnalysisResultTypes.DiskFreeSpace, ObjectName = s.Key, ReferenceValue = s.Value.Key, CurrentValue = s.Value.Value, Factor = Settings.Instance.DatabaseDiskFreeSpaceRatio + SizePercentage });
            }
        });

        //database data file & log file space
        databases.AsEnumerable().ForEach(d =>
        {
            var name = d["name"].ToString();
            if (!systemDatabases.Contains(name))
            {
                var database = GetDatabaseInfo(name);
                var databaseSpace = new Dictionary<databasefiletypes, /> { { DatabaseFileTypes.Data, 0 }, { DatabaseFileTypes.Log, 0 } };
                database.AsEnumerable().ForEach(f =>
                {
                    var key = (DatabaseFileTypes)Convert.ToInt32(f["type"]);
                    databaseSpace[key] += Convert.ToInt64(Convert.ToDecimal(f["Size"]) / Size1K);
                }
                );
                bool? shrink = null;
                if (databaseSpace[DatabaseFileTypes.Log] > databaseSpace[DatabaseFileTypes.Data] / 100 * Settings.Instance.DatabaseDataLogSpaceRatio)
                    shrink = false;
                else
                {
                    var logSpaces = SQLHelper.Query("DBCC SQLPERF(LOGSPACE)", GetServerInfo(name));
                    var logSpace = logSpaces.Select(string.Format("[Database Name] = '{0}'", name));
                    if (logSpace.Length > 0)
                    {
                        var logSpacedUsed = Convert.ToDouble(logSpace[0]["Log Space Used (%)"]);
                        if (logSpacedUsed < Settings.Instance.DatabaseDataLogSpaceRatio)
                            shrink = true;
                    }
                }
                if (shrink != null)
                    analysisResult.Add(new AnalysisResult { ResultType = AnalysisResultTypes.DatabaseLogSpace, ObjectName = name, ReferenceValue = databaseSpace[DatabaseFileTypes.Log], CurrentValue = databaseSpace[DatabaseFileTypes.Data], Factor = Settings.Instance.DatabaseDataLogSpaceRatio + SizePercentage, Key = (bool)shrink ? 1 : 0 });
            }
        });

对于表空间，使用了sp_spaceused，关键代码：

本文链接

登陆澳洲一周年记

2011-05-10T02:05:00Z

那天，2010年，5月，14日。在爸妈开的大排档忙完后，爸妈说今晚不开门了，送你去机场。

一行人，4辆车，8个大袋子，抵达新白云机场。三叔硬塞了3000人民币给我，我说：在澳洲用不上吧？他说：可以的，拿着吧。泪别了爸妈，过了跟验尸般的海关，匆忙赶上快要起飞的CZ325，后来因为暴雨天气，在飞机上坐了3个多小时才起飞，时间是凌晨12点多。这是我生平第一次坐飞机，也是第一次出远门。

飞机在空中颠簸，一路轰鸣，空间小，腿一直无法伸展，整夜无法入睡。总在想：在澳洲，没亲戚，没朋友，什么都要从头再来，顿时感到很空虚

经过9个小时的飞行，8000多公里，早上，通过窗口，看见了梦想中的澳洲，错落有致的房子和大片大片的绿树，天气非常好，蓝天，没有白云。感觉真好。

那天，2010年，5月，15日。

下飞机的时候太激动，把护照都掉地上了，乘务员提醒才拿回来。过海关，没有人。。。估计当时就我们的飞机降落。等了20分钟，数来数去，还是感觉丢了个包。过程中还有海关的警犬来嗅我的包，然后盘问了几句，在我的机票上签了个名就走了。

过海关比较顺利，看见隔壁关卡的都在验尸般的审查，把包都拆了逐个看，我前面的女同胞不大懂英语，先前她就已经在别的区域审查过一次，现在又被审查，她让我跟海关人员解释她没带违法的东西。经过我的解释，海关放走了她。轮到检查我了，我的8个大包都不用打开，只让我把随身的小包打开，看见里面有一个红包，就问我这是啥，我解释说是家里的老人给出远门的孩子的一种祝福，这是中国传统，然后他们就微笑一下，说"welcome to australia"，让我过关了。

过关之后第一个看见的不是鬼佬，是一个说普通话的华人，估计是机场工作人员，笑容可掬，感觉很温暖。

朋友来接我机，把我送到早就在网上租好的房子，房东热情地请我们吃饭，然后我们就算安顿下来了。之后房东带我们去附近的westfield购物中心逛，告诉我们哪里来什么东西便宜。

来之前总听大家说在澳洲人手一部汽车，因为没有不方便。来了第二周，我们买了一部二手的丰田camry，3300刀。声明一下：我是反对日货的。。。

顺带说一下，来澳洲2个月，我们花了2万澳元。。。

然后我们花了一个多月把所有手续都办了：税号（TFN），买电话，centrelink登记拿福利，family assistance office登记拿医保（medicare）。

之后就去了银行开帐号拿信用卡，给家里开通电话和上网。

当然还有女儿上幼儿园。这里的幼儿园收费很贵，3岁以上每天要80多澳元。扣除了childcare之后你还得给60刀左右（视乎你的家庭收入）。

然后就开始找工作了，在seek.com.au等招聘网站狂发简历，前后发了100个简历吧，电话面试了几间，面对面面试了2次，然后就拿到现在公司的offer了，前后花了2周。

随后就去RTA(相当于中国的交管局)考车牌，因为澳洲承认你在外国的驾驶经验，满3年就可以转成本地的FULL驾照了。我路试考砸了2次，第三次才通过，估计是因为3次考试都是同一个考官。。。我一定不会忘记他。。。你懂的。。。第三次考试的时候，我直接跟他说：我再也不想看见你了。。。

刚来的时候，碰上每年2次的政府回收大件垃圾时间，大家可以把自家不用的东西放门口，别人如果看见适合自己的，可以拿回家。刚开始观察了几天，后来趁天色黑了，就偷偷地去捡了张很大的饭桌，感觉像个讨饭的。。。不过后来拿多了，胆子也壮了，也习以为常了。

还没有上班之前，我们每周都到各大海滩玩，去那些国家公园野餐烧烤，感觉很舒服。这里的自然环境很好，花草树木非常茂盛，公园很多，在国家公园里面，一般都有河流和大片的森林，大家可以划船，有钱人会开游艇，出海享受阳光和钓鱼。如果你在夏天去海滩，看见那些全体裸体在晒阳光的，别想歪，因为很多都这样干，不论男女。。。

2010年，7月，老婆怀上孩子了。

老婆想有个自己的家，然后我们就开始到处看房子，前后看了20间房子，最后选了间在westfield购物中心旁边的，说是购物和交通都方便。

2010年，11月，入住新买的房子。

2011年，4月，16日，儿子出世。这是我们家在澳洲本土出生第一代华人，所谓的ABC（Australia Born Chinese），在美国也叫ABC，不过一般人喜欢叫ABC做香蕉人，黄皮白心，表面是华人，实际心是属于美国的。

我们给儿子起了英文名，当然也保留了中国的名字做中间名(middle name)，目的就是想他记住自己来自中国。

然后给孩子申请了福利，出生证，在6月10日入了澳洲国籍，拿了澳洲护照。

今天，2011年，5月，10日。登陆澳洲一周年记。

来澳洲1周年，我们安顿下来，买来部老爷车，找到了工作，买了间二手房子，生了个儿子，儿女双全，感觉比较充实。

在澳洲，最大的感慨是这里的税收重，一般收入家庭，一个月里面，起码一周是给政府打工的。

不过，税收是取之于民，用之于民。譬如：拿了medicare，你看病就不用给钱了，药费减半，这里一般看病不去医院，而是去看GP(General Practise)，相当于在中国的社区医院，一般一个人会有一个固定的GP。住院也是不需要给钱的，不过需要在公立医院排队，曾经有人说过一个案例，有人等半年等不下去，自己坐飞机回中国看病去了。当然你也可以买私人医疗保险，这样你就可以去私立医院，排队的时间会短很多，而且可以选择医生。其他医药器械可能会更便宜，譬如避孕器，原价235刀，现在只需要35刀。

因为是多元化国家，中国称澳洲是联合国，各色人种，来自120多个国家和地区的人民生活在一起。因为语言的不同，澳洲政府提供了免费的翻译服务，任何时候，你都可以打电话给翻译服务处要求提供超过120种语言的翻译服务。而且，还可以预约翻译人员到达现场为你提供服务，譬如你不懂英语，你要去医院看病，你就可以让医院给你预约翻译，全程在你身边为你服务。

去图书馆借书、多媒体也是不需要钱的，一般每个社区都有一些公园或者游乐场，也是免费的。

上面说过，上幼儿园，政府会给你一些补贴。

我的女儿每个月会拿到几百澳元的补贴，所谓的牛奶金等。如果你租房，还有租房补贴。一部家庭1个孩子儿子在租房的话，一个月大概可以拿1000澳元的补贴。

在这里生孩子，根据你的收入，一般人会拿到baby bonus，所谓的新生儿奖励，5200多澳元。

另外，你买房子，政府还会给你补贴，我们就那了7000澳元的所谓赞助。

每财年结束，大家都可以申请退税，政府根据你过去一年的收入，如果多给了税，可以退回来。

这里的生活质量比中国高，食品安全，蔬菜水果特别的鲜甜，蓝天白云多。

当然，这里有种族歧视，鬼佬跟你竖中指问候你常有。

总体来说，这里适合生活。建议想过自在生活的各位，可以考虑过来。

本文链接

开源项目：SQL Monitor 3.0.8

2010-11-22T11:17:00Z

什么事

前几天有点无聊，想写点新东西。

公司的系统复杂，SQL Server经常会CPU占用100%，SQL Monitor就是用来帮助分析什么SQL的执行导致这个问题的。

怎么办

原理非常简单，首先是获取所有SQL进程，方法有多种：

1.sys.sysprocesses：在SQL Server 2000就声明要被移除了，不建议使用。实际上sys.sysprocesses是用以下的dmv来映射的。

2. sp_who

3. sp_who2：跟sp_who类似，获取的字段比sys.sysprocesses和以下的dmv要少。

4. sys.dm_exec_sessions等相关dmv：

select * from sys.dm_exec_connections
select * from sys.dm_exec_requests
select * from sys.dm_exec_sessions

关于sys.dm_exec_sessions等dmv，可以参看这里：http://msdn.microsoft.com/en-us/library/ms187997.aspx

然后dbcc INPUTBUFFER(spid)来获取指定进程执行的SQL，最后用kill spid来中止SQL进程。

实际调试起来，会用到其它复杂的SQL，譬如是什么锁，锁定哪个数据库中的哪个表，等等，下一篇文章才写吧。

能干嘛

1. 监控SQL Server的进程和Job，查看当前执行的SQL/命令，并终止之。

2. 对象浏览器，跟 SQL Server Management Studio 类似

3. 查询数据

4. 数据库收缩、备份、分离等

5. 性能分析

6. 对象/脚本查找

什么要求

这个项目是用C# 3.5写的，为了省事，用了Linq，所以要求.net框架为3.5 Client Profile，如果你把Linq换成for/next，可以在2.0环境使用。

在哪里

项目地址：http://sqlmon.codeplex.com/

最新版本下载：SQLMon 3.0 alpha 8 src SQLMon 3.0 alpha 8 binary

本文链接

划时代的新产品即将上市，敬请期待！

2010-08-11T09:56:00Z

一切即将改变

本文链接

分布式文件快速搜索-技术细节分析(开源/并行)

2010-07-26T10:37:00Z

系列文章

1.分布式文件快速搜索(多计算机并行/多种算法)

2.分布式文件快速搜索的设计与实现(开源/分布式计算/并行)

3.分布式文件快速搜索-技术细节分析(开源/并行)

前言

在上一篇文章中，对分布式文件快速搜索的设计与实现进行了说明。今天，将对具体的实现细节进行分析。

文件的检索

文件获取

1). 一般地，用Directory.GetDirectories()加上SearchOption.AllDirectories来获取某个的目录下的所有文件（包括任意层子文件）。但在这里会采用自行递归获取，每获取一层目录的文件，都会预先根据SearchTypes条件(如文件大小、文件名、修改时间、属性等)来碰撞。具体参看WorkV7FindFileRunner.FindLocal方法。

2). 相比递归获取文件列表，我们可以直接读取物理磁盘的MFT(Master File Table)主文件表，这样不需要逐个目录递归，直接顺序获取所有文件夹和文件记录，速度可以比递归快10倍以上。在Windows NT便引入的NTFS文件系统，拥有USN Journal（文件日志），每个文件的变化（添加、修改、删除、更名等）都会被记录，在通过MFT获取所有文件后，每次运行，只需要判断一下系统的变化并记录便可，无需重新扫描整个磁盘。

哈希获取

在使用SearchTypes条件过滤完成后，使用MD5CryptoServiceProvider来获取MD5哈希值。当然，你可以使用SHA1CryptoServiceProvider计算哈希值，如果你觉得MD5不可靠，具体参看WorkUtils.HashMD5File。

实际的哈希获取，会使用缓存。缓存的实现使用快速二进制序列化，原理是判断缓存数据库是否存在一样的文件信息（文件名、大小和修改时间），如果匹配，则返回已经存在的哈希值，否则就获取新的哈希值。具体参看LocalHashStorage。

文件的匹配/比较

文件的匹配有3种方式：完全一致、包含以及全文索引。

完全一致

完全一致，直接使用哈希值比较。
包含

适用于运行时搜索，判断文本文件中包含的内容。目前直接使用File.ReadAllText(file).IndexOf(keyword, StringComparison.InvariantCultureIgnoreCase)来判断，可能遇到的问题应该是文件太大导致内存溢出。
全文索引

可索引文件的全文内容会自动缓存，支持自定义扩展接口IFileContentIndex，目前内置了微软的IFilter实现。具体参看LocalFileContentIndexStorage。

并行计算的处理

实现

因为不是.NET3.5/4，没有PPL，只能模拟并行，来源参看分布式文件快速搜索v7.0(多计算机并行/多种算法)。原理是使用ThreadPool.QueueUserWorkItem各个任务，使用ManualResetEvent记住每个任务的状态，并用WaitHandle.WaitAll等待所有任务完成。具体参看ParallelProcessor.ExecuteParallel。

public static void ExecuteParallel(IParallelWorker[] methods)
        {
            if (methods.Length > 0)
            {
                // Initialize the reset events to keep track of completed threads
                ManualResetEvent[] resetEvents = new ManualResetEvent[methods.Length];

                // Launch each method in it's own thread
                for (int i = 0; i < methods.Length; i++)
                {
                    resetEvents[i] = new ManualResetEvent(false);
                    ThreadPool.QueueUserWorkItem(new WaitCallback(delegate(object index)
                    {
                        int methodIndex = (int)index;

                        // Execute the method
                        methods[methodIndex].Run();

                        // Tell the calling thread that we're done
                        resetEvents[methodIndex].Set();
                    }), i);
                }

                // Wait for all threads to execute
                WaitHandle.WaitAll(resetEvents);
            }
        }

线程安全

在多线程的环境中，最常见的问题是线程安全。.NET 2.0中，Dictionary是不安全的，我用网上封装的SynchronizedDictionary，当然，我们还可以使用折腾箱子的HashTable。在.NET 4.0中，你可以使用ConcurrentDictionary。

除了集合，在访问FileStream等对象的情况，你都必须注意保证线程安全，否则数据会跟实际预想不一致。

任务切分

并行计算最关键是如何切分任务。在上一篇文章中我已经简略地说明，实际的逻辑比较复杂。首先，根据要搜索的文件组和最大任务数进行切分，在每个任务中，判断文件夹是否为远程文件夹，如果是，则使用分布式搜索，否则本地搜索，具体参看WorkV7FindFileRunner。

在上述所有文件夹搜索任务都完成后，聚合搜索结果，再根据网络/本地切分任务。对于本地文件夹，则判断是否为同一个物理磁盘，如果是，则动态使用并行计算以实现加速。具体参看WorkV7.Find()。

具体参看上一篇文章的流程图、WorkV7FindFileRunner(第一次根据文件大小、名称等过滤)和WorkV7FindResultRunner(根据文件属性过滤后再根据匹配方式搜索)。

分布式的实现

这是本程序的最大特点。分布式的原理就是在各个节点部署一个监听程序，多个节点组合成一个grid，在监听的同时，也可以作为客户端发送请求。

数据的传输

本程序没有使用XML作为数据载体，而是使用了自定义的格式：文件头+数据体（如文件内容等），文件头包括了命令等信息。整个内容可选压缩算法，每个数据包在最后自动添加结束标记，以便在TCP中识别。

协议

分布式文件快速搜索自定义了协议接口，内置了对HTTP、TCP和FTP的支持，你可以自由添加各种协议。每种网络连接，都会使用异步处理，避免堵塞请求。

譬如：

c:\temp\abc.txt
\\lancomputer\temp\abc.txtt
http://1.2.3.4:88/foo/abc.txt
tcp://1.2.3.4:55/foo/abc.txt
ftp://1.2.3.4/foo/abc.txt
pop3://1.2.3.4:101/foo/abc.txt
skydrive://foo/abc.txt
dropbox://foo/abc.txt
AmazonS3://foo/abc.txt
flicker://foo/abc.jpg
facebook://foo/abc.jpg

HTTP

每个数据包都使用POST方式，在可选压缩后把数据写入Request.GetRequestStream，具体参看HTTPFileWorkProvider。在服务器端，使用HttpListener监听，在获得每个HttpListenerRequest后，调用基类(BaseManager)的ProcessRequest处理Request.InputStream，具体参看WorkV7HTTPManager

HttpListener有点诡异，使用fooListener.Prefixes.Add()来定义监听的路径。在调用HttpListener之前，你需要使用HttpListener.IsSupported判断一下你的操作系统是否支持：必须XP SP2或以上、Win2003、Vista、08、Win7。HttpListener本身不支持SSL，但你可以httpcfg.exe来配置，之前我参看的是一篇英文的文章，现在一下子找不到，大家就凑合用中文的吧：配置HttpListener侦听SSL连接详解。
TCP

每个具体的操作，会先使用AsynchronousClient进行连接，服务器使用AsynchronousSocketListener进行监听，在Received事件处理客户端发送来的请求，具体参看TCPFileWorkProvider和WorkV7TCPManager。
FTP

使用.NET内置的FTPWebRequest，具体参看FTPFileWorkProvider。

大数据的传输

在下一个大版本中，将会提供对文件同步的支持。文件传输，有很多现成的软件可以做参考。我的设想是：把文件动态切分成多个小块以减少内存的占用，标记之，成功就记录一个，失败/断开后下次传输，则可以断点续传。当然，一样可选压缩算法，以提高传输性能。

代码下载

点击这里下载：Filio.zip

项目地址

本项目已经在http://filio.codeplex.com/ 开源

本文链接

分布式文件快速搜索-设计与实现(开源/并行)

2010-07-20T00:50:00Z

系列文章

1.分布式文件快速搜索(多计算机并行/多种算法)

2.分布式文件快速搜索的设计与实现(开源/分布式计算/并行)

3.分布式文件快速搜索-技术细节分析(开源/并行)

特点

1.分布式：支持通过互联网查找任意多计算机，支持TCP/HTTP；
2.访问安全:基于角色的访问控制（RBAC），支持定义远程访问的账户、允许访问的目录等；
3.快速：

a).充分发挥多核CPU的性能，自动进行并行计算；

b).自动使用NTFS特性快速检索文件，比普通检索速度提升10倍以上；
4.智能：自动识别同一部机器上的不同物理磁盘，自动加速；
5.高效：哈希值、全文索引快速存取，网络压缩传输；
6.可扩展性内容搜索：内容匹配、全文索引，支持接口；

前世

这个程序的灵感，可以参考这里详细的说明：分布式文件快速搜索(多计算机并行/多种算法)

原来的目的只是查找本计算机的重复文件，因为3TB的磁盘空间，放了太多电影、图片、音乐，有不少是重复。刚开始，对每个文件内容都进行哈希值计算，速度非常慢。后来改成先用文件大小碰撞，碰撞后重复的几率就极大地减少了，然后再进行文件内容哈希，速度就有了巨大的提升。再后来，支持了文件名、文件时间和属性等过滤条件，可用性也增大了。

但是我不满足现有的速度，觉得现在的CPU都是多核的，我们可以使用多线程来充分利用多核的威力。单纯的多线程处理容易，new Thread就能跑了，但我们的目的是把大量的查找任务切割，分而治之，然后同时执行，并等待所有任务都完成再继续下一步工作，这就是并行计算的目的。

.NET 3.5 SP1开始有了Parallel Extensions，4.0内置了Parallel Processing Library(PPL)，当然还有一系列的相关类，如ConcurrentDictionary等（终于解决了2.0引入的Dictionary不是线程安全需要自己手工封装的问题了）。有了这些，我们就可以进行并行计算了。

在引入了多线程检索文件之后，我还不满足现有的速度。经过分析，可以判断检索的文件是否在不同的物理磁盘（不是一个磁盘的不同分区），则可以在本机动态使用并行计算。

我还不满足目前的功能：局限于现有计算机，作为不大。日常工作，我们需要对不同的计算机进行搜索，当然，都是局域网内，我们可以映射网络磁盘。但如果是互联网上的计算机，你就无能为力了。所以就有了现在的网格文件快速搜索。

必须说明的是，网格文件快速搜索不是一个完整的软件，只是闲得头痛而拿来练手的实验性程序，目前能做的只是检索、删除相同/不同计算机上的文件。

今生

所谓网格，就是分布式，跟Web2.0所谓Tag就是分类一样，互联网包装的概念层出不穷。

要实现在不同的计算机之间检索文件，并聚合结果，我们需要做的工作颇多。首先，我参考了google的MapReduce。MapReduce，实际就是2个步骤，分配工作，然后聚合结果。在对多个计算机进行检索，就是分配多个任务，每个任务检索指定的计算机，等待所有检索任务完成，再聚合结果。

接着，我们需要对任务进行分配。分配的原则是远程按机器分组，本地按磁盘分组。在分配好任务之后，我们需要在每个计算机运行一个监听程序接受其它机器的请求。监听使用的是异步TCP，使用事件来通知程序进行业务处理。在监听程序运行后，客户端判断要检索的文件夹位于远程计算机，使用异步TCP连接，连接成功后，发送要检索的文件夹以及身份信息，在通过身份认证之后，便可以进行文件检索。当检索完成后，返回结果给请求端，请求端在所有计算机的检索都完成后，对结果进行组合。

如果远程计算机HTTP无法连接（如监听程序没有启动），会自动尝试TCP链接，如果仍然失败会自动容错并忽略。

现在，网格文件快速搜索正式成为了文件搜索，而不是以前的重复文件查找了。

搜索流程

上述的步骤只是大概的过程，实际搜索流程要更复杂。整个搜索过程分2大步：第一步是根据文件的大小/名称/时间/属性等进行过滤，然后对存在相同的文件再进行文件内容哈希值判断。

对于互联网上的机器搜索，第一步必须返回所有搜索内容，而不是仅仅返回重复的内容，因为我们现在检索不是本地计算机，是多个互联网计算机，譬如计算机A存在文件1.jpg，计算机B也存在同样的1.jpg，但你必须把计算机A和B的结果聚合了才知道2个jpg文件相同，所以检索各个计算机的文件，第一次回返回所有文件信息，在结果返回聚合后，得出大小/名称/时间/属性相同的结果，再对这些文件进行文件内容哈希值处理。文件内容哈希值的处理过程跟文件属性检索类似，但是哈希值是以磁盘文件形式缓存了，每次获取文件内容哈希值之前，先判断文件的基本属性（文件名、大小、修改时间）是否与哈希数据库一致，如果匹配，使用数据库中的值，否则计算新的哈希值。

对于文件内容匹配，分3种情况：

1.完全匹配：使用哈希值判断，哈希值会在本地缓存；

2.内容包含：运行时判断；

3.全文索引：对可以抽取内容的文件进行动态索引，本地缓存；

全文索引支持接口扩展，目前内置了对微软的IFilter接口的实现，即将添加对lucene.net和hubbledotnet的支持。

具体流程看下图：

将来

你可以充分发挥想象力，把它应用到不同的领域。如果你应用了，记得告诉我，我会很高兴它能被别人使用。

TODO

参看分布式文件快速搜索(多计算机并行/多种算法) 。

使用

参看分布式文件快速搜索(多计算机并行/多种算法) 和下面的代码。

代码下载

点击这里下载：Filio.zip

实际使用，不需要V1*-V5*这些类，现在只是用来对比测试速度的，如果不测试，可以删除这些类。

项目地址

本项目已经在http://filio.codeplex.com/ 开源

本文链接

分布式文件快速搜索V7.0(多计算机并行)

2010-07-13T12:19:00Z

系列文章

1.分布式文件快速搜索V7.0(多计算机并行/多种算法)

2.分布式文件快速搜索的设计与实现(开源/分布式计算/并行)

3.分布式文件快速搜索-技术细节分析(开源/并行)

前言

这个话题很古老了，用C#实现的也很多，很明显我是在造轮子了。不过我今晚闲得头疼，在codeplex碰见看见一个项目，就是找重复文件的，项目代码我没看，我只是想找事情做。对开发人员来说，舒展一下手指的最佳办法是敲代码了。我最喜欢通过写代码来学东西了，看着枯燥的书本就没劲。

需求

找重复文件，首先是要获取文件的特征，很久以前用CRC，虽然最近MD5已经给中国某大学研究员验证不可靠，不过我还是喜欢MD5:)。你可以选择SHA1，换个类名就可以了。

实现

实现的办法很简单，就是把所有文件的特征都算出来，然后比较。

问题是，如果盲目地对每个文件都先获取哈希特征，再进行比较，那会很浪费时间，譬如你的磁盘没有重复文件，或者有些很巨大的不重复文件，那你就要把绝大部分时间浪费在无谓的哈希获取上了。

所以，我们先使用文件大小进行碰撞，再对相同大小的进行碰撞，可以极大地提高效率。为什么选择文件大小呢？因为如果文件大小不一样，那就不可能内容重复了吧？为什么不同时选择文件的修改时间？文件修改时间不一样，文件内容也是可以一样的，对不？既然我们的目的只是找内容相同的文件（不是文件名相同），那我们就可以无视文件名和文件修改时间了。允许选择不同的特征组合，譬如先是单纯的文件大小，或者文件大小+文件名+创建时间。

实现过程是用Dictionary来根据特征分组，碰撞（相同文件内容）就放到该特征下的重复文件列表，最后找出所有重复的文件。

程序很简单，主要是原始文件和重复文件的选择。函数可以指定重复目录，如果匹配到是在重复目录下的，就认为是可删除的（相对保留原始文件而言，本程序没有删除代码。。。）重复的文件，如果没有指定重复目录，则自动选择第一个文件为原始文件。

并行的实现

一直想用多线程来实现提速，今晚闲得头疼，就简陋地实现。大概实现步骤：因为不是.NET3.5/4，所以没有PPL，只能模拟并行了：C# Parallelism: Executing Methods in Parallel in .NET 3.5 。原理是封装了ThreadPool，结合ManualResetEvent和WaitHandle.WaitAll等待所有线程完成。在.NET 2.0中，Dictionary不是线程安全的，又不想花时间自己写封装，就只有在网上找了个封装好的线程安全的Dictionary。多线程的思想是：分配任务，分而治之。业务逻辑是自行切割要检索的文件夹到不同的线程，得到结果后，最终实现并行计算。

网上发现的最quick & dirty的代码

http://www.hosca.com/blog/post/2010/04/13/using-LINQ-to-detect-and-remove-duplicate-files.aspx

这个代码极大地让感到我今晚写的代码很冗余。。。它用了几个Linq的语句：Select所有文件，GroupBy哈希值，然后ForEach删除。。。Linq是很精妙。。。不过这个办法跟我的老慢速算法是大同小异的，所以速度也是可以无视的。

我实现的代码(让你容易找点......)

老规矩，vs2005+c#2.0，quick & dirty，没linq，没var，没有自动属性。不要跟代码规范较真，也不要纠缠为什么代码都放一个文件，纯粹是为了方便粘贴到博客而已，在产品开发中，6000多个手工写的类我都是很有组织地归类的:)

代码中有7个算法：

WorkV1：最原始的，对每个文件都进行哈希值比对；

WorkV2：较新的算法，先用文件大小（或加上文件名、创建日期、修改日期等）进行过滤，匹配的文件组合才进行哈希值比对；

WorkV3：新的多线程算法，把多线程应用到文件检索和文件哈希值获取；

WorkV4：测试发现如果把多线程应用到文件读取，则性能急剧下降，但仅获取文件信息，则有很大提升，虽然瓶颈在文件读取，但起码在检索信息上，比起V2有了提升；

WorkV5：新的算法，文件检索使用多线程，文件哈希值获取则动态判断文件所在地物理磁盘，如果不是同一个物理磁盘，则是使用多线程，否则采用跟V2一样的算法；因为判断物理磁盘引入了System.Management.dll，使用了DriveIdentification条件编译；

WorkV6：新的算法，支持对互联网上的计算机进行搜索，哈希值的快速存取，文件内容搜索，全文索引；

WorkV7：最新的算法，添加了对协议提供者模式的支持，可以自由添加各种访问协议；

在这里比较性能其实意义不大，以为不同机器比较不同的文件，差异太大了，譬如你的机器有2个文件，一个巨大，一个渺小，用新的快速算法，微秒间完成，用老的慢算法，则你可能要去睡一觉。

程序有3个条件编译：DRIVEID启用物理磁盘识别（需要引用System.Management.dll）,VERBOSE启用详细的调试信息,LoG启用保存日志

使用

看代码，判断支持多个文件夹。先Find出重复文件组合(指纹/相同文件列表)，再用FindAll找出可以删除的所有重复文件。

如果要实现分布式搜索，必须在被搜索的计算机运行WorkV7Manager的实例，具体参看代码。

本地搜索

string duplicateFolder = @"d:\backup";
Dictionary<string, MatchFileItem> result;
BaseWork worker = new WorkV6();
result = worker.Find(new FileURI[] { new FileURI(@"c:\download\"), new FileURI(duplicateFolder)}
, new string[] { }, "", SearchTypes.Size | SearchTypes.Name, MatchTypes.ContentSame);
List<string> duplicatedFiles = worker.FindAll(result, duplicateFolder);

分布式搜索

初始化

//first initialize some settings
WorkUtils.Initialiaze(new KeyValuePair<string, string>(), CompressionMethods.GZip, new System.Net.WebProxy());

服务器端

BaseManager manager = new WorkV6HTTPManager();//you can use WorkV6TCPManager
Dictionary<string, UserAccess> users = new Dictionary<string, UserAccess>();
users.Add("user", new UserAccess("user", "pass", UserRights.Discover | UserRights.Search));
string[] allowedPaths = new string[] { @"e:\temp\New Folder" };
manager.Start(users, allowedPaths, 8880);

客户端

FileURI remoteFolder = new FileURI(@"202.2.3.4:8880/e:\temp\New Folder", "user", "pass", 0, ObjectTypes.RemoteURI);
Dictionary<string, MatchFileItem> result;
result = Worker.Find(new FileURI[] { new FileURI(@"c:\download\"), remoteFolder }
, new string[] { }, "YOUR KEYWORD HERE", SearchTypes.Size, MatchTypes.ContentExtract);
List<string> matchFiles = Worker.FindAll(result, string.Empty);

已知问题

本程序并没有考虑因为文件量巨大而会造成内存不足等问题，这个就留到以后我闲得更头痛的时候再考虑吧。

如果你要同时测试多种算法，那是不可能的，因为所有算法的瓶颈是对文件的哈希值获取，而这个方法允许Windows对已经访问的文件进行缓存和预取（pre-fetch），这样当你测试完第一个算法，再用第二个算法的时候，就会发现秒级完成。所以你每测试出一个结果，就应该重启电脑。。。

未知问题

如果你发现有什么bug，麻烦告诉我，我喜欢学习:)

改进

1.2010-7-16 v1；

2.2010-7-14 v2 添加了对选择文件名/修改时间/创建时间为重复标准的支持；重构代码，引入了基类，方便测试；

3.2010-7-14 v2.1 再次重构，并添加了对指定文件类型的支持，允许正则表达式；

4.2010-7-15 v3 增加了对多线程的支持，速度提升；

5.2010-7-16 v3.1 修正了从v2开始出现的重复测试问题；

6.2010-7-16 v4 仅应用多线程于文件查找；

7.2010-7-16 v5 动态支持多磁盘多线程提速；

8.2010-7-16 v5.1 增加了对使用文件属性过滤的支持，并重构了部分代码，并修正了动态多磁盘的判断；

9.2010-7-19 v5.2 允许单纯地查找匹配大小/文件名而不计算哈希值，增加了对文件名过滤的支持，并重构了部分代码，加入了对动态多磁盘的容错；

10.2010-7-20 v6 实现了网格搜索

10.2010-7-20 v6.1 添加了对文件发现的支持，如果远程计算机没有发布可访问的目录，则不进行搜索

10.2010-7-20 v6.2 添加了对删除重复文件的支持，并改造了用户访问机制

11.2010-7-21 v6.3 添加了对快速存取哈希值的支持；

12.2010-7-21 v6.4 修正了快速存取哈希值的异常问题；

13.2010-7-23 v6.6 添加了对HTTP协议、内容匹配、全文索引的支持；

14.2010-7-26 v6.7 添加了对HTTP、TCP压缩传输的支持；

15.2010-7-28 v6.8 添加了NTFS USN Journal技术，检索文件信息速度提升10倍，源代码：http://filio.codeplex.com/SourceControl/changeset/changes/74232

16.2010-7-31 v6.9 添加了对基于角色的访问控制（RBAC）的权限管理；

17.2010-8-11 v7.0 添加了对协议提供者模式的支持；

TODO

~~1.目前来看，改进速度的办法是多线程了，多个线程获取目录文件，然后多个线程对文件列表进行哈希获取。~~ 在V3中添加了对多线程的支持；

~~2.添加对分布式（互联网上的机器）的支持；~~在v6中添加了对网格搜索的支持；

~~3.添加对删除文件的支持；~~ 在v6.1中添加了对删除文件的支持；

4.~~文件内容哈希值存储，以便以后快速获取（同时记录文件名、大小、修改时间和哈希值，任一不匹配则认为文件改变了）~~在v6.3中实现了哈希值快速存取

5.~~添加对HTTP协议的支持~~；在v6.6中实现了对HTTP协议的支持

6.~~添加对搜索文件内容的支持：完全匹配、全文索引~~；在v6.6中添加了对文件内容匹配、全文索引的支持；

7.添加对lucene.net和hubbledotnet的支持；

8.~~添加对缓存的压缩支持~~；在V6.6添加了对缓存压缩的支持；

9.~~添加对网络传输(HTTP/TCP)的压缩支持~~；在v6.7添加了对网络压缩传输的支持；

10.添加对文件同步的支持：chunck/index/count，断点续传

11.~~添加对基于角色的访问控制（RBAC）~~；在v6.9中添加了对其的支持；

12.如果检索互联网上的计算机，如果指定搜索目录存在大量的文件，则返回结果可能会因为太大而造成网络超时等问题；

13.添加对HTTP/TCP的SSL连接的支持；

14.~~添加对NTFS的USNJournal支持，可以比普通的检索文件信息(Directory.GetFiles)快10倍。。。~~ 在v6.8中添加了对其的支持

代码下载

点击这里下载：Filio.zip

项目地址

本项目已经在http://filio.codeplex.com/ 开源

本文链接

自动输出SQL Server对象依赖列表到EXCEL文件

2010-07-12T06:25:00Z

前言

类似的软件很多年前写过，不过现在在新国家，新环境，印度佬（我囧）资深系统分析员要求我：给现有的数据库的所有存储过程分别列举所有依赖的对象。

需求

现在数据库很老很大，表不多，200来个，但数据量很大：最大的数据表2亿6千万条，每天增加50多w，925个存储过程。

系统大，耦合度很高，牵一发而动全身。人员变动频繁，接手的人员要在修改之前，就得花相当长的时间来分析关联性。

所以，印度资深系统分析员要求我在一个EXCEL文件中，把925个存储过程的所有依赖的对象（表、函数、视图、存储过程等等）都列举出来。

分析

手工逐个打开存储过程去做，对写软件的人来说是很傻的事情，一般重复性工作，如果预计耗时超过3分钟，我就会卷起袖子写个代码。

工作内容有3部分：

1.获取所有的存储过程。我们可以用sysobjects这个系统表，它存储了所有的表、存储过程、视图、函数等。其中存储过程的xtype是P，CLR存储过程，类型是PC；函数的类型是FN/IF或TF，CLR函数类型是FS；视图类型是V；表类型是U。

2. 获取某存储过程所依赖的对象，当然是先google了。很久之前我就知道可以用系统存储过程sp_depends来获取，不过还是应该看看还有什么更好的办法。首先我发现这个：http://www.mssqltips.com/tip.asp?tip=1294 。作者研究出4种办法：INFORMATION_SCHEMA.ROUTINES/sp_depends/syscomments/sp_MSdependencies。其中就有我一直在用的sp_depends。其它办法有的霸王硬上弓：用charindex来遍历存储过程内容，或者用LIKE来判断。。。。。我服了，写代码的风格千差万别，一些是[Foo]，一些是Foo，而且不同的存储过程名称可能存在完全给另外一个包含，譬如Foo Foo1 AFoo等。

看完之后，我还是觉得使用sp_depends相对靠谱。为什么说“相对靠谱”呢？因为我发现它某些情况下也会没有返回所有依赖的，这应该是SQL Server的bug吧？如果要把所有依赖都找回来，你可以去修改被遗忘的引用存储过程，随便加个空行，运行（就是保存结果），你会发现之前没有显示的依赖终于出现了。而且，sp_depends会输出重复的记录。。。所以我们在代码中要剔除掉。

3. 既然是输出到EXCEL文件，我们就需要找相应的代码。在这个网站已经有很多EXCEL文件生成的代码了，譬如NPOI。我最后采用了GemBox的，因为够轻便。本来想用更轻便的MyXLS，但发现它不支持单背景色。当然你也可以用别的，譬如XML格式的EXCEL文件，这是你个人的选择了。

解决了上述的3个问题，我们就可以大干一场了。我用VS2005+C#2.0，因为公司还是在用古老的XP搭配VS2005，鬼佬国家要求什么都正版，自然不会像我们在中国那样随便就升级到2010了。所以只能放弃LINQ，老老实实地写老派的代码了。

以下代码没有什么特别的，都是循环所有存储过程，然后循环每个存储过程的依赖对象，然后排序输出（先按照类型，然后按照名称）。本来想用DataTable.Select对多个字段排序，但后来发现没效果，也没心思去研究为什么，干脆就改成写一个IComparer。

代码写得很quick and dirty，10来分钟的事情，不要跟代码规范较真。

代码（让你容易找点。。。）

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Drawing;
using System.Data;
using System.Data.SqlClient;
using GemBox.Spreadsheet;

namespace SQLServerDocumenter
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length == 0)
            {
                args = new string[4];
                args[0] = "database";
                args[1] = "datasource";
                args[2] = "user";
                args[3] = "password";
            }

            string db = args[0];
            string dataSource = args.Length > 1 ? args[1] : string.Empty;
            string user = args.Length > 2 ? args[2] : string.Empty;
            string password = args.Length > 3 ? args[3] : string.Empty;

            Work work = new Work();
            work.Progress += new EventHandler<ProgressEventArgs>(OnWorkProgress);
            work.Run(db, dataSource, user, password);

            Console.WriteLine();
            Console.WriteLine("all done!");
            Console.Read();
        }

        private static void OnWorkProgress(object sender, ProgressEventArgs e)
        {
            Console.WriteLine(e.Status);
        }
    }

    public class Work
    {
        public event EventHandler<ProgressEventArgs> Progress;

        public void Run(string Database, string DataSource, string UserName, string Password)
        {
            ExcelFile xls = new ExcelFile();
            ExcelWorksheet sheet = xls.Worksheets.Add("Dictionary");
            CellStyle nameStyle = new CellStyle(xls);
            nameStyle.FillPattern.SetSolid(Color.DarkGray);
            nameStyle.Font.Color = Color.Black;
            nameStyle.Font.Weight = ExcelFont.BoldWeight;

            sheet.Cells[0, 0].Value = string.Format("{0} database dictionary", Database);

            sheet.Cells[4, 0].Value = "Name";
            sheet.Cells[4, 0].Style = nameStyle;

            sheet.Cells[4, 1].Value = "Dependencies";
            sheet.Cells[4, 1].Style = nameStyle;

            sheet.Cells[4, 2].Value = "Type";
            sheet.Cells[4, 2].Style = nameStyle;

            string connectionString = string.Format("Password={0};Persist Security Info=True;User ID={1};Initial Catalog={2};Data Source={3}", Password, UserName, Database, DataSource);
            using (SqlConnection connection = new SqlConnection(connectionString))
            {
                connection.Open();

                int index = 5;

                AddObjects(connection, "'P'", "Stored Procedures", new List<string>(new string[] { "sp_alterdiagram", "sp_creatediagram", "sp_dropdiagram", "sp_helpdiagramdefinition", "sp_helpdiagrams", "sp_renamediagram", "sp_upgraddiagrams" }), sheet, ref index);
                AddObjects(connection, "'FN','IF','TF'", "Functions", new List<string>(), sheet, ref index);
                AddObjects(connection, "'V'", "Views", new List<string>(), sheet, ref index);

                connection.Close();
            }

            string path = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location) + @"\" + Database + ".xls";
            xls.SaveXls(path);
        }

        private void AddObjects(SqlConnection Connection, string Types, string Name, List<string> IgnoreNames, ExcelWorksheet Sheet, ref int Index)
        {
            CellStyle itemStyle = new CellStyle();
            itemStyle.FillPattern.SetSolid(Color.LightGray);
            itemStyle.Font.Color = Color.Black;
            itemStyle.Font.Weight = ExcelFont.BoldWeight;
            CellStyle typeStyle = new CellStyle();
            typeStyle.FillPattern.SetSolid(Color.Yellow);
            typeStyle.Font.Color = Color.Black;
            typeStyle.Font.Weight = ExcelFont.BoldWeight;
            Sheet.Cells[Index, 0].Value = Name;
            Sheet.Cells[Index, 0].Style = typeStyle;

            Index++;

            DataSet data = new DataSet();
            using (SqlCommand command = new SqlCommand(string.Format("SELECT * FROM sysobjects WHERE XTYPE IN ({0}) ORDER BY NAME", Types), Connection))
            {
                SqlDataAdapter adapter = new SqlDataAdapter(command);
                adapter.Fill(data);
                if (data.Tables.Count > 0)
                {
                    DataTable objects = data.Tables[0];
                    for (int i = 0; i < objects.Rows.Count; i++)
                    {
                        string objectName = objects.Rows[i]["name"].ToString();
                        if (!IgnoreNames.Contains(objectName))
                        {
                            Sheet.Cells[Index, 0].Value = objectName;
                            Sheet.Cells[Index, 0].Style = itemStyle;
                            DataSet data2 = new DataSet();
                            using (SqlCommand command2 = new SqlCommand(string.Format("exec sp_depends '{0}'", objectName), Connection))
                            {
                                adapter = new SqlDataAdapter(command2);
                                adapter.Fill(data2);
                            }
                            if (data2.Tables.Count > 0)
                            {
                                DataTable dependencies = data2.Tables[0];
                                Dictionary<string, KeyValuePair<string, string>> uniqueDependencies = new Dictionary<string, KeyValuePair<string, string>>();
                                for (int j = 0; j < dependencies.Rows.Count; j++)
                                {
                                    string itemName = dependencies.Rows[j]["name"].ToString();
                                    if (itemName.ToLower().StartsWith("dbo."))
                                        itemName = itemName.Substring(4);
                                    if (!uniqueDependencies.ContainsKey(itemName))
                                        uniqueDependencies.Add(itemName, new KeyValuePair<string, string>(itemName, dependencies.Rows[j]["type"].ToString()));
                                }
                                List<KeyValuePair<string, string>> allItems = new List<KeyValuePair<string, string>>();
                                foreach (KeyValuePair<string, KeyValuePair<string, string>> item in uniqueDependencies)
                                {
                                    allItems.Add(new KeyValuePair<string, string>(item.Value.Key, item.Value.Value));
                                }
                                allItems.Sort(new KVPComparer());
                                foreach (KeyValuePair<string, string> item in allItems)
                                {
                                    Index++;
                                    Sheet.Cells[Index, 1].Value = item.Key;
                                    Sheet.Cells[Index, 2].Value = item.Value;
                                }
                            }
                            else
                            {
                                Index++;
                                Sheet.Cells[Index, 1].Value = "(N/A)";
                            }
                            Index += 3;
                            AddProgress(string.Format("({0}/{1}) {2} done", i + 1, objects.Rows.Count, objectName));
                        }
                        else
                            AddProgress(string.Format("({0}/{1}) {2} ignored", i + 1, objects.Rows.Count, objectName));
                    }
                }
                else
                    Sheet.Cells[Index, 0].Value = "(N/A)";
            }

            Index++;
        }

        private void AddProgress(string Status)
        {
            if (Progress != null)
                Progress(this, new ProgressEventArgs(Status));
        }
    }

    public class ProgressEventArgs : EventArgs
    {
        private string status;
        public string Status
        {
            get { return status; }
            set { status = value; }
        }

        public ProgressEventArgs(string Status)
        {
            status = Status;
        }
    }

    internal class KVPComparer : IComparer<KeyValuePair<string, string>>
    {
        public int Compare(KeyValuePair<string, string> x, KeyValuePair<string, string> y)
        {
            int compare = string.Compare(x.Value, y.Value);
            if (compare == 0)
                return string.Compare(x.Key, y.Key);
            else
                return compare;
        }
    }
}

使用

使用很简单，编译（你得找个EXCEL输出代码。。。），在命令行（改成Win应用也可以啊）输入3个参数：数据库名、服务器名和密码。当然，大家都有自己的品味，喜欢怎么改输出格式就怎么改吧。

结论

印度资深系统分析员只是让我给个EXCEL文件，没有让我写代码，所以把我自己的研究成果发上来也无伤大雅。一般我都喜欢把写的东西弄成可重用的，不仅仅为了一个固定的目的，所以也便有了4个参数和同时输出函数和视图的依赖列表。

最后输出的的EXCEL文件有6000多行，我真怀疑到底有多少人愿意看这个文件。。。

题外话

其实漂洋过海来了澳洲，来到这个都是印度开发人员的公司，经常让我做些工作，最后都不采纳的，或许，印度人跟哪个国家的人都一样，对the new guy表现好的就要让他halt一下。。。枪打出头鸟，人怕出名猪怕壮，新人在试用期间又要给老板看表现，但又不能让老员工有压力，混口饭吃不容易。

譬如让我用了一个星期研究SSIS，成果都出来了，最后给无视了。所以，也便有了数据处理利器-SSIS入门与进阶这篇文章，省得让我的研究给扔到大海。

譬如让我研究给那个巨大的数据表分区，我辛苦写了详细的计划，步骤，相关的SQL，注意事项等等等，最后我问起来，一句话答复：我不会应用的。

另外一个题外话：同事给报表执行一个复杂的SQL查询（存储过程），以前都是在几秒内完成的，某天开始，要4分钟，怎么改都是要4分钟，任何机器都是，但在数据库本身所在的SSMS跑却正常。后来在业务执行插入SET ARITHABORT ON，问题解决。最后发现是SQL Plan出了问题，只需要修改一下存储过程（随便加个空行），保存便可，不需要SET ARITHABORT ON。

另外第二个题外话，我发现印度程序员的确能做事的，对要做的事情很熟悉，譬如那个资深系统分析员，对新业务的分析是很快捷准确的。不过写的代码和SQL的规范和质量。。。。，就跟大家平时所说的差不多了

更新

2010-07-13 1.增加了对函数和视图的支持；2.增加了对用户名的支持；3.分离了业务逻辑和界面，现在可以Copy&Paste到WinForm/WPF/WebForm/ASP.NET MVC...

本文链接

数据处理利器-SSIS入门与进阶

2010-06-29T06:42:00Z

使用SSIS，首先是因为工作需要，其次，在澳洲找工作的2个星期里，我发现招聘需求中有太多技术我没有掌握了，其实这些技术，只需要几天就可以入门，几个星期就可以进阶，为什么不花一点时间去掌握一门新的技术呢？多一门技术与少一门差异是很大的，招聘需求往往会写明必须掌握的技术，你缺一门，你就不好意思打招呼了。

SSIS是从MS SQL 2005开始引入的，实际上是DTS的马甲，是SQL Server Integration Service的缩写。DTS也好，SSIS也罢，都是ETL（Extract Transform Load）工具，一般用来导入数据到数据库。SSIS比普通的ETL更进一步，它是可视化的，用Visual Studio来开发，包文件(*.dtsx)采用的是XML格式。跟Office2007+系列文档扩展名一样，都是???x，代表xml格式，但他没有压缩成zip文件罢了。

我在新格式的工作内容是研究SSIS的性能。公司是做能源管理的，每隔一段时间（如15分钟）需要从测量表中提取数据，不断积累后，一个测量表5年的数据有231MB，134万条。目前每天要处理6500多个文件，现有活动数据是3亿条记录。

注意：因为移民到了澳洲悉尼，系统和开发环境全部是英文，我也不知道中文对应是什么，所以以下说明全部使用英文，并加上我猜想的中文。

首先使用SSIS创建一个简单的Integration Services Project: File->New->Project->Business Intellegence Projects->Integration Services Project

（新建项目1）

（新建项目2）

添加一个Foreach Loop Container

, 双击这个Foreach Loop Container，点击左边的Collection，选择来源文件目录(Folder)，输入文件类型(Files)。

点击Variable Mappings，点击New Variable，在Name输入变量名称。这个变量是目录循环中每个文件的值，稍后会用在每个文件的处理中。

再在里面添加一个Data Flow Task

，双击这个Data Flow Task，进入了Data Flow标签（Control Flow右边）。因为原始文件是从测量表读取出来然后写到CSV文件的，所以我们使用Flat File Source(就是文本文件，CSV文件也属于这类)。

双击Flat File Source，Flat File connection manager，点右边的New新建一个文本文件连接，给连接一个名字，选择一个例子文件，按照你的情况输入header rows to skip(跳过头列)，如果第一列是列名称，你应该输入1。

点击Advanced(高级)，给每列选择正确的数据类型，确定。

点击Columns（列），给每列起个名字。

在我们的数据中，都是基本的设备、日期、温度、湿度、气压等等。但某些记录是错误的（譬如没有日期），这些记录就要忽略，日期是细分为：年、月、日、小时、分钟的，必须合并，还有温度、湿度某些情况是没有的，你就要处理为NULL。

对于错误的记录（日期为空），我们要添加一个Conditional Split，在Condition(条件)中输入 “LEN(TRIM(Year)) > 0”(只需要判断年是否为空)。

关于表达式，需要特别说明一下：你可以选作左边的变量或者列，或者右边的各种内置函数。你只需要直接拖放变量、列或者函数到输入框便可。

对于完整的日期，我们需要添加一个Derived Column(派生列)，从Conditional Split拖放关系，要求你选择跳转到指定流程的条件。

双击该派生列，在Expression(表达式)中输入“Year + "-" + Month + "- " + Day + " " + Hour + ":" + Minute + ":00"”（构造标准的日期格式，如：2010-06-29 16:11），日期类型选database timestamp（根据你自己的实际情况吧）。

对于NULL数值类型，你也需要添加一个派生列，然后在表达式中输入LEN(TRIM(Temperature)) > 0 ? (DT_R8)Temperature : NULL(DT_R8)。这里用DT_R8是因为温度是double。

然后添加一个导入目标，我们的目的是把数据导入到MS SQL Server，所以添加一个SQL Server Destination，双击进入编辑

点击New新建一个数据库连接。

点击Mapping（映射），把CSV文件的列对应到数据库表

接下来就是运行了，如果你正确设置，数据自然会导入到数据库。

这里需要注意，SSIS的设计有颇多的bug，譬如下面提及的脚本编译问题，还有在设计器中，不能通过编辑目标数据来直接编辑连接，你要双击下方的控件列表。另外，当你编辑连接，你会发现之前选择的例子文件会丢失，每次你都必须重新选择。

如果要发布到SQL Server，你要修改SSIS的项目属性：Project->(your project name) Properties->Deployment Utility->CreateDeploymentUtility->True。然后双击bin\Deployment下面的Deployment文件，按照提示一步步Next便可（建议安装到MS SQL Server，而不是文件系统）。如果要查看已经安装的，打开SQl Server Management Studio，选择Integration Services，打开。

在开发SSIS的过程中，你可能会遇到一些诡异的情况。譬如：
1.类型转换，你在Prorgress（进度）标签中可以查看详细的结果，但往往结果都比较含糊。一般都是类型没有选对，譬如SSIS会自动选回字符串类型，你又要手工改回database timestamp
2.目标数据库中的数据表字段变化了，或者来源文件格式变了，你运行，肯定错误，但在Progress(进度)中，你难以看出个门道。一般看见设计图中的出现警告或者错误小图标，你鼠标挪上去停一下，就会给个模糊的提示，双击，会提示你修正。

一些特别情况：
1.内置的控件无法满足需要，怎么办？自己写控件：陈希章同学写的为SSIS编写自定义任务项(Task)之入门篇。这里还有另外一个例子：执行SQL Job并等待其结束。

2.需要复杂的处理：在Control Flow中用Script Task，在Data Flow中用Script Component；

关于脚本：添加一个Script Task，双击，点击Script(脚本)，如果你是SQL 2005 SP1或以下，你就必须选PrecompileScriptIntoBinaryCode，否则你将无法正确运行。或者你给2005安装SP2；

3.你需要让SSIS执行并尽量等待你去做其他事情（矛盾啊。。。），你可以添加一个Script Task，输入System.Threading.Thread.Sleep(想多长就多长)；

关于变量：你需要注意变量的作用域。一般的作用域是Package(包)。在脚本中，如果你想访问变量，你就必须在ReadOnlyVariables（只读变量）和ReadWriteVariables（可读写变量）中输入变量名称（多个变量用逗号分隔）。然后在编辑脚本代码中，使用Dts.Variables("YourVariableName")来访问变量。

关于邮件发送，如果使用内置的Send Mail Task，你会发现无法指定登陆用户名和密码。我改用脚本调用sourceforge上opensmtp，或者，你可以使用MS SQL Server自带的邮件功能，然后用SQL Excute Task执行，譬如：

exec msdb.dbo.sp_send_dbmail @profile_name = 'Foo',
    @recipients = 'FooReceiver',
    @subject = 'FooSubject',
    @body = 'FooBody'
    @body_format = 'Text'

稍后我会给出使用最老套的c#代码导入数据方式(包括多线程方式等多种方式)，和SSIS比较性能，因为我觉得写c#代码怎么也不能输给SSIS这种重量级的工具啊，所以我卷起袖子就大干一场，写了多种方式，但结果很特别。。。。。。

本文链接

.NET开源项目的前世和今生系列之 .NET开源压缩文档处理的前世和今生

2009-12-25T06:56:00Z

序这是《.NET开源项目的前世和今生系列》之一，如上一篇《.NET开源数据库的前世和今生》。这些系列是我对过去10年中了解的.NET开源项目的总结。《.NET开源项目的前世和今生系列》的大概结构如下(假如我还有心思写下去的话)：《.NET开源数据库的前世和今生》上、下《.NET开源文档处理的前世和今生》：压缩、Office(Word/Excel/PPT/MAPI)、其它(PDF/RTF)《.NE...

博客园_灵感之源

开源项目：高级SQL Server监控、性能图、分析与优化、版本控制

登陆澳洲一周年记

开源项目：SQL Monitor 3.0.8

划时代的新产品即将上市，敬请期待！

分布式文件快速搜索-技术细节分析(开源/并行)

分布式文件快速搜索-设计与实现(开源/并行)

分布式文件快速搜索V7.0(多计算机并行)

自动输出SQL Server对象依赖列表到EXCEL文件

数据处理利器-SSIS入门与进阶

.NET开源项目的前世和今生系列 之 .NET开源压缩文档处理的前世和今生

.NET开源项目的前世和今生系列之 .NET开源压缩文档处理的前世和今生