对1500条数据循环Delete top.

SET @Count = 0

WHILE(@Count < 21)

BEGIN

SET @Count = @Count + 1
Update dbo.DataFeedItemDetailSSB_Record
SET message_body.modify
('declare default element namespace "http://soa.newegg.com/SOA/USA/InfrastructureService/V10/PubSubService";
replace value of
(/Publish/Node/DataFeedItemDetailV10/Body/ItemDetailInfoList[1]/ItemDetailInformation[sql:variable("@Count")]/ItemBasicInformation/UPCCode/text())[1]
with
sql:column("DataFeedItemDetailSSB_Record.RowID")*100 + sql:variable("@Count"),
')
WHERE Rowid <= 20

Update dbo.DataFeedItemDetailSSB_Record
SET message_body.modify
('declare default element namespace "http://soa.newegg.com/SOA/USA/InfrastructureService/V10/PubSubService";
replace value of
(/Publish/Node/DataFeedItemDetailV10/Body/ItemDetailInfoList[1]/ItemDetailInformation[sql:variable("@Count")]/ItemStaticInformation/OwnerSKUNumber/text())[1]
with
sql:column("DataFeedItemDetailSSB_Record.RowID")*100 + sql:variable("@Count")
')
WHERE Rowid <= 20

END

更新DataFeedItemDetailSSB_Record表中xml字段中的UPCCode和OwnerSKUNumber，其中UPCCode在一个List中。

目前，只有邀请才能注册，链接地址如下：

http://bai.sohu.com/user/reg/invite.do?u=144504&type=0&t=1244742447837&s=05528eca7da9b299fa856acbcb4a0291

阳光牧场，真心话，说秘密，很好玩！

比如有个实体类ItemEntity，有个接口类ItemData，完成转换只需如下

ItemData data = CommonTransfer.ToTarget<ItemData,ItemEntity>(entity);

即可，要提供性能可以使用Emit自己写IL代码，这个太复杂不想研究了，还有个方法就是使用.NET 3.5的新特性，表达式树。有时间研究下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Reflection;
using System.Collections;

namespace CommonTransfer
{
    public static class CommonTransfer<TTarget, TSource>
        where TTarget : class, new()
        where TSource : class, new()
    {
        public static TTarget ToTarget(TSource source)
        {
            return Transform(typeof(TTarget), typeof(TSource), source) as TTarget;
        }

        private static object Transform(Type targetType, Type sourceType, object propInfo)
        {
            Object result = targetType.GetConstructor(Type.EmptyTypes).Invoke(null);
            PropertyInfo[] propInfos = targetType.GetProperties();
            PropertyInfo[] sourcePropInfos = sourceType.GetProperties();
            for (int i = 0; i < propInfos.Length; i++)
            {
                PropertyInfo sourceProp = sourcePropInfos.FirstOrDefault(p => p.Name == propInfos[i].Name);
                if (sourceProp == null)
                {
                    throw new Exception(string.Format("{0} is not exist in source type", propInfos[i].Name));
                }
                object value = sourceProp.GetValue(propInfo, null);
                if (IsCollectionProperty(sourceProp) && value != null)
                {
                    MethodInfo addMethod = propInfos[i].PropertyType.GetMethod("Add");
                    object temp = null;
                    if (propInfos[i].PropertyType.GetGenericArguments()[0] == typeof(string))
                    {
                        temp = new List<string>();
                        foreach (string str in value as IList)
                        {
                            object[] strArray = { str };
                            addMethod.Invoke(temp, strArray);
                        }
                    }
                    else
                    {
                        temp = propInfos[i].PropertyType.GetConstructor(Type.EmptyTypes).Invoke(null);
                        foreach (var item in value as IList)
                        {
                            if (item != null)
                            {
                                object[] args = { Transform(propInfos[i].PropertyType.GetGenericArguments()[0], item.GetType(), item) };
                                addMethod.Invoke(temp, args);
                            }
                        }
                    }
                    propInfos[i].SetValue(result, temp, null);
                }
                else
                {
                    if (sourceProp != null
                        && sourceProp.PropertyType.IsClass
                        && sourceProp.PropertyType != typeof(string)
                        && value != null)
                    {
                        value = Transform(propInfos[i].PropertyType, sourceProp.PropertyType, value);
                    }
                    else
                    {
                        value = Convert.ChangeType(value, propInfos[i].PropertyType);
                    }
                    propInfos[i].SetValue(result, value, null);
                }

            }
            return result;
        }

        private static bool IsCollectionProperty(PropertyInfo propInfo)
        {
            if (Array.IndexOf(propInfo.PropertyType.GetInterfaces(), typeof(IList)) > -1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}

Starting, Attaching, Executing and Exiting

Getting Help

Issuing Commands

Examining the Unmanaged Environment

Working with Extension DLLs (e. g., SOS)

SOS Commands

SOS 2.0 Commands

我的主页，http://uniq.mp/！

http://www.newsqx.com/n7008c12.aspx      菲律宾侵占南沙群岛

刚过了多事的2008，看来2009也不会平凡啊。过去一年国家领导人关注老百姓已经太多了，现在收到洋人的欺负，不知道会有什么样的行动，但愿一切顺利。

既然菲律宾都都已经宣布南沙群岛归他所有，还要说什么吗？直接派兵过去灭了菲律宾，把菲律宾划归中国所有得了。难怪会没有反应，都被人家占领了那么长时间了，资源被掠夺的差不多了吧。还好台湾问题解决的差不多了，不然的话，如果台湾突然宣布独立，不知道中国会不会有所行动。真的很悲哀，严正抗议，有用吗？屎都拉到你头上了，还抗议，想想都好笑。中国对南沙群岛的主权得到国际上的承认 ，既然得到世界的广泛承认，那么出兵就是名正言顺，想破脑袋都想不出，中国有什么好忌惮的。难道真是中国威胁论？

。。。 。。。

Unicode is typically used in database applications which are designed to facilitate code pages which extend beyond the English and Western Europe code pages (Erland Sommarskog, a native of Sweden, refers to this set as "Germanic and Romance languages"), for example Chinese. Unicode is designed so that extended character sets can still "fit" into database columns. What this means is that Unicode character data types are limited to half the space, because each byte actually takes two bytes (Unicode is sometimes referred to as "double-wide"). For more information on Unicode, see Unicode.org. Note that there are many encoding schemes in the Unicode standard, but SQL Server only supports one: UTF-16.

While using Unicode is a design choice you can make in building your own applications, some facilities in SQL server require it. One example is sp_executeSQL. If you try the following:

EXEC sp_ExecuteSQL 'SELECT 1'

You will get this error:

Server: Msg 214, Level 16, State 2, Procedure sp_executesql, Line 1
Procedure expects parameter '@statement' of type 'ntext/nchar/nvarchar'.

You can get around this in two ways:

-- (a) using the N prefix
EXEC sp_ExecuteSQL N'SELECT 1'
-- (b) using a variable
DECLARE @sql NVARCHAR(100)
SET @sql = N'SELECT 1'
EXEC sp_ExecuteSQL @sql

Note that implicit conversion makes the N prefix optional in case (b); however, for legibility and consistency, you should always use the prefix when defining Unicode strings. One reason is that leaving it off can actually change your data if it contains Unicode characters (losing the additional information), as in the following example:

DECLARE @n NVARCHAR(10)
SET @n = 'a'
PRINT @n
SET @n = N'a'
PRINT @n

The first assignment, which didn't use the N prefix, gets printed as a regular a. Only the second maintains the character that was actually supposed to be represented. As you can imagine, if you are intending to support data entry in foreign languages and code pages, you will likely need to test for Unicode support (making sure that such columns support Unicode, and that data won't be lost when passed into stored procedures, functions, etc.). Note that your application will need to handle Unicode as well; for example, when you try to print this character from ASP...

<%
Response.Write("a")
%>

...it actually prints out the string aa. (This result might depend on your codepage and regional settings.) So you might consider translating your data into its ASCII equivalent, e.g. a = ā.
Another reason you want to avoid implicit conversion is that there are some potentially serious performance issues. Consider the following quite simple repro:

USE tempdb
GO
CREATE TABLE a
(
b VARCHAR(3),
c NVARCHAR(3)
)
CREATE INDEX b ON a(b)
CREATE INDEX c ON a(c)
GO
SET NOCOUNT ON
INSERT a SELECT 'foo', N'foo'
INSERT a SELECT 'bar', N'bar'
DECLARE
@b VARCHAR(3),
@c NVARCHAR(3)
SELECT
@b = 'foo',
@c = N'foo'
SELECT * FROM a WHERE b = @b
SELECT * FROM a WHERE b = @c
SELECT * FROM a WHERE c = @b
SELECT * FROM a WHERE c = @c
SELECT * FROM a WHERE b LIKE @b
SELECT * FROM a WHERE b LIKE @c
SELECT * FROM a WHERE c LIKE @b
SELECT * FROM a WHERE c LIKE @c
DROP TABLE a

Paste the code into Query Analyzer, turn execution plan on, and let her rip. You'll observe the following breakdown of percentage of work (roughly, depending on your hardware):

VARCHAR = VARCHAR
4.48%

VARCHAR = NVARCHAR
13.31%

NVARCHAR = VARCHAR
4.48%

NVARCHAR = NVARCHAR
4.48%

VARCHAR LIKE VARCHAR
4.48%

VARCHAR LIKE NVARCHAR
13.31%

NVARCHAR LIKE VARCHAR
4.48%

NVARCHAR LIKE NVARCHAR
4.48%

Now, that's not the whole story; we all know that there are many other factors, such as I/O, that will impact the actual time each portion of the query takes. The key is that implicit conversion *can* cause a table scan instead of an index seek, and on larger tables this can really hurt. While it's important to understand why this happens and in which scenarios, my recommendation is to match your character-based datatypes as explicitly as possible.
One other thing to watch out for: your database may be using Unicode without your knowledge. If you upsize from Access to SQL Server, for example, character-based text columns might be translated to Unicode (I believe this is a catch-all technique; in case Access was storing Unicode strings, or if you might be storing Unicode strings later, you won't lose data or require changes). I think the Access upsizing tools should be updated to force a conscious choice, so that you aren't wasting space for nothing, and so that you know that you made a decision at all.
For a more thorough discussion of Unicode and the N prefix, please see KB #239530, this MSDN article, and this Google thread.
In other RDBMS platforms, or in the ANSI and/or ISO specifications, you might see prefixes other than N being used against values. (Current versions of SQL Server only support Unicode.) Here are the additional monikers I am aware of:

B
This is used to denote a BINARY string expressed in bits (0 and 1 only)

X
This is used to denote a BINARY string expressed in hexadecimal (0 -> F)