public static IList<EntityKeyMemberInfo> ParseMemberNames(EntityInfo entity, string names, bool ordered = false, Action<string> errorAction = null)
 {
     var specs = StringHelper.SplitNames(names);
       var mList = new List<EntityKeyMemberInfo>();
       foreach(var spec in specs) {
     bool desc = false;
     string[] parts;
     if(ordered) {
       parts = StringHelper.SplitNames(spec, ':');
       if(parts.Length > 2) {
     if(errorAction != null) errorAction(spec);
     continue;
       }
       string strDesc = parts.Length == 1 ? "asc" : parts[1];
       switch(strDesc.ToLowerInvariant()) {
     case "":  case "asc": desc = false; break;
     case "desc": desc = true; break;
     default:
       if(errorAction != null)
         errorAction(spec);
       continue;
       }//switch
     }//if ordered
     else
       parts = new string[] { spec, null };
     var member = entity.GetMember(parts[0]);
     if(member == null) {
       if(errorAction != null)
     errorAction(spec);
     }
     mList.Add(new EntityKeyMemberInfo(member, desc));
       }//foreach spec
       return mList;
 }

        public static int Delete( int id, IEntity obj, EntityInfo entityInfo )
        {
            List<IInterceptor> ilist = MappingClass.Instance.InterceptorList;
            for (int i = 0; i < ilist.Count; i++) {
                ilist[i].BeforDelete( obj );
            }

            int rowAffected = 0;
            rowAffected += deleteSingle( id, entityInfo );
            if (entityInfo.ChildEntityList.Count > 0) {
                foreach (EntityInfo info in entityInfo.ChildEntityList) {
                    rowAffected += deleteSingle( id, MappingClass.Instance.ClassList[info.Type.FullName] as EntityInfo );
                }
            }
            if (entityInfo.Parent != null) {
                IEntity objP = Entity.New( entityInfo.Parent.Type.FullName );
                rowAffected += deleteSingle( id, Entity.GetInfo( objP ) );
            }

            for (int i = 0; i < ilist.Count; i++) {
                ilist[i].AfterDelete( obj );
            }

            CacheUtil.CheckCountCache( "delete", obj, entityInfo );

            return rowAffected;
        }

        public static int DeleteBatch( String condition, EntityInfo entityInfo )
        {
            if (strUtil.IsNullOrEmpty( condition )) {
                return 0;
            }

            String deleteSql = new SqlBuilder( entityInfo ).GetDeleteSql( condition );
            logger.Info(LoggerUtil.SqlPrefix+ "delete sql : " + deleteSql );

            List<IInterceptor> ilist = MappingClass.Instance.InterceptorList;
            for (int i = 0; i < ilist.Count; i++) {
                ilist[i].BeforDeleteBatch( entityInfo.Type, condition );
            }

            IDbCommand cmd = DataFactory.GetCommand( deleteSql, DbContext.getConnection( entityInfo ) );
            int rowAffected = cmd.ExecuteNonQuery();
            logger.Info( "delete : " + rowAffected + " records affected" );
            cmd.Connection.Close();

            for (int i = 0; i < ilist.Count; i++) {
                ilist[i].AfterDeleteBatch( entityInfo.Type, condition );
            }

            // update cache  timestamp
            CacheTime.updateTable( entityInfo.Type );

            return rowAffected;
        }

        private void AddDeleteStatements(IEntity entity, EntityInfo entityInfo)
        {
            foreach (var valueInfo in entityInfo.Values)
            {
                foreach (var value in entity.GetValues(valueInfo))
                {
                    var builder = new ComplexCommandBuilder();
                    var idParameter = value.Id.ToParameter();
                    builder.AddParameter(idParameter);
                    var whereClause = string.Format("{0}.{1} = {2}", valueInfo.Name, valueInfo.Identifer.Name, idParameter.Name);
                    var statement = new DeleteStatement(valueInfo.Name, whereClause);
                    builder.AddStatement(statement);
                    Add(builder);
                }
            }

            foreach (var childInfo in entityInfo.Children)
            {
                foreach (var child in entity.GetChildren(childInfo))
                {
                    var builder = new ComplexCommandBuilder();
                    var idParameter = child.Id.ToParameter();
                    builder.AddParameter(idParameter);
                    var whereClause = string.Format("{0}.{1} = {2}", childInfo.Name, childInfo.Identifier.Name, idParameter.Name);
                    var statement = new DeleteStatement(childInfo.Name, whereClause);
                    builder.AddStatement(statement);

                    AddDeleteStatements(child, childInfo);
                    Add(builder);
                }
            }
        }

        private static Result Update( IEntity obj, EntityInfo entityInfo ) {
            Result result = Validator.Validate( obj, "update" );
            if (result.IsValid == false) return result;

            List<IInterceptor> ilist = MappingClass.Instance.InterceptorList;
            for (int i = 0; i < ilist.Count; i++) {
                ilist[i].BeforUpdate( obj );
            }

            updateSingle( obj, entityInfo );
            if (entityInfo.Parent != null) {
                IEntity objParent = Entity.New( entityInfo.Parent.Type.FullName );
                setParentValueFromChild( objParent, obj );
                updateSingle( objParent, Entity.GetInfo( objParent ) );
            }
            CacheUtil.CheckCountCache( "insert", obj, entityInfo );


            for (int i = 0; i < ilist.Count; i++) {
                ilist[i].AfterUpdate( obj );
            }
            result.Info = obj;

            // update cache  timestamp
            CacheTime.updateTable( entityInfo.Type );

            return result;
        }

        public EntityInfo TargetEntity; //for delete, insert, update

        #endregion Fields

        #region Constructors

        public LinqCommand(EntityQuery query, LinqCommandType commandType, LinqCommandKind kind, EntityInfo targetEntity)
        {
            Kind = kind;
              CommandType = commandType;
              Query = query;
              TargetEntity = targetEntity;
        }

 public static string toString(EntityInfo entityInfo)
 {
     entity = entityInfo.getName + " = {\n";
     addGenericAttributes(entityInfo);
     addComponentsAttributes(entityInfo);
     return entity + "\n},";
 }

 public static EntityMemberMask Create(EntityInfo entity, string propertiesOrGroups)
 {
     var invalidNames = new StringList();
       var mask = new EntityMemberMask(propertiesOrGroups, entity);
       var props = propertiesOrGroups.SplitNames(',', ';');
       foreach (var name in props) {
     //first try member
     if (string.IsNullOrWhiteSpace(name))
       continue;
     var grp = entity.GetPropertyGroup(name);
     if (grp != null) {
       foreach (var m in grp.Members)
     mask.Set(m);
       continue;
     }
     var member = entity.GetMember(name);
     if (member != null) {
       mask.Set(member);
       continue;
     }
     //name is invalid
     invalidNames.Add(name);
       }
       if (invalidNames.Count > 0)
     Util.Throw("Properties/subgroups [{0}] not found in entity {1}.", string.Join(",", invalidNames), entity.EntityType);
       return mask;
 }

 /// <summary>
 ///     Initializes a new instance of the <see cref="T:System.Object" /> class.
 /// </summary>
 public EntityRelationSide(EntityInfo entity, NavigationPropertyEntityInfo property, NavigationType navigationType, SimplePropertyEntityInfo[] keyColumns)
 {
     Property = property;
     NavigationType = navigationType;
     KeyColumns = keyColumns;
     Entity = entity;
 }

 private void AddRootCommandBuilder(EntityInfo entityInfo)
 {
     var builder = new ComplexCommandBuilder();
     builder.AddStatement(new CreateTableStatement(entityInfo));
     
     Add(builder);
 }

 public EntityCommand BuildCrudSelectAllPagedCommand(EntityInfo entity)
 {
     var cmd = AddCommand(entity.Name + "_SelectAllPaged", "Selects all entities.", EntityCommandKind.SelectAllPaged, entity);
       cmd.Parameters.Add(new EntityCommandParameter("__skiprows", typeof(int), 0, 0));
       cmd.Parameters.Add(new EntityCommandParameter("__maxrows", typeof(int), 0, int.MaxValue));
       return cmd;
 }

        public SelectStatement(EntityInfo entityInfo, string rootName, string rootIdAlias, string orderByClause)
        {
            if (entityInfo.IsRoot)
            {
                builder.AppendFormat("select distinct {0}.* from {0}", entityInfo.Name);
                if (!string.IsNullOrEmpty(rootName) && !string.IsNullOrEmpty(rootIdAlias))
                    builder.AppendFormat(" inner join {0} on {0}.{1} = {2}.{3}", rootName, rootIdAlias, entityInfo.Name, entityInfo.Identifier.Name);
                if (!string.IsNullOrEmpty(orderByClause))
                    builder.AppendFormat(" order by {0}", orderByClause);
                builder.Append(";");
            }
            else
            {
                builder.AppendFormat("select distinct {0}.* from {0}", entityInfo.Name);

                var previousName = entityInfo.Name;
                var previousIdName = entityInfo.Identifier.Name;
                var parent = entityInfo.Parent;
                while (parent != null)
                {
                    builder.AppendFormat(" inner join {0} on {0}.Id = {1}.Parent", parent.Name, previousName);
                    previousName = parent.Name;
                    previousIdName = parent.Identifier.Name;
                    parent = parent.Parent;
                }

                if (!string.IsNullOrEmpty(rootName) && !string.IsNullOrEmpty(rootIdAlias))
                    builder.AppendFormat(" inner join {0} on {0}.{1} = {2}.{3}", rootName, rootIdAlias, previousName, previousIdName);

                if (entityInfo.Sequence != null)
                    builder.AppendFormat(" order by {0}.{1}", entityInfo.Name, entityInfo.Sequence.Name);
            }
        }

        private static String getInsertSql( EntityInfo entityInfo )
        {
            String str = "insert into " + entityInfo.TableName + " (";
            String fStr = "";
            String vStr = ") values(";
            for (int i = 0; i < entityInfo.SavedPropertyList.Count; i++) {
                EntityPropertyInfo info = entityInfo.SavedPropertyList[i];

                if ((
                    ( /**/!DbConfig.Instance.IsAutoId || !(info.Name.ToLower() == "id") || (entityInfo.Parent != null))
                    && info.SaveToDB)
                    && (!info.IsList && !info.IsList)
                    )
                {
                    String col = info.ColumnName ?? "";
                    fStr = fStr + col + ", ";
                    vStr = vStr + entityInfo.Dialect.GetParameter( info.ColumnName ) + ", ";
                }
            }
            fStr = fStr.Trim().TrimEnd( ',' );
            vStr = vStr.Trim().TrimEnd( ',' );
            str = str + fStr + vStr + ")";
            logger.Info( LoggerUtil.SqlPrefix + entityInfo.Name + " InsertSql：" + str );
            return str;
        }

 public override void Apply(EntityInfo victim)
 {
     if (victim != null)
     {
         victim.ReduceHealth(value * Time.deltaTime, DamageType.Effect);
     }
 }

 protected override void OnStateLogicInit(EntityInfo npc, long deltaTime)
 {
     AiStateInfo info = npc.GetAiStateInfo();
     info.Time = 0;
     info.HomePos = npc.GetMovementStateInfo().GetPosition3D();
     info.Target = 0;
     NotifyAiInitDslLogic(npc);
 }

 public EntityCommand(string commandName, string description, EntityCommandKind kind, EntityInfo entity, EntityKeyInfo selectKey = null)
     : this(commandName, description, kind)
 {
     TargetEntityInfo = entity;
       Area = entity.Area;
       TargetEntityType = entity.EntityType;
       SelectKey = selectKey;
 }

        public CreateTableStatement(EntityInfo entityInfo)
            : this(entityInfo.Name)
        {
            AddColumns(entityInfo.Elements);

            foreach (var dataType in entityInfo.DataTypes)
                AddColumns(dataType.Elements);
        }

        // TODO: performance
        private static IEntity findByIdFromChild( long id, EntityInfo entityInfo ) {
            foreach (EntityInfo ei in entityInfo.ChildEntityList) {
                IEntity result = ObjectDB.FindById( id, new ObjectInfo( ei ) );
                if (result != null) return result;

            }
            return null;
        }

 private void IdleHandler(EntityInfo npc, long deltaTime)
 {
     AiStateInfo info = npc.GetAiStateInfo();
     info.Time += deltaTime;
     if (info.Time > 100) {
         info.Time = 0;
     }
 }

 void Awake()
 {
     if (eInfo == null)
     {
         // Make a reference to the EntityInfo of this Buffmanager's specific character.
         eInfo = GetComponent<EntityInfo>();
     }
 }