C# IQueryAdapter.setQuery方法代码示例

        public void Initialize(IQueryAdapter dbClient)
        {
            dbClient.setQuery("SELECT id,caption,min_rank FROM navigator_flatcats WHERE enabled = 2");
            DataTable dPrivCats = dbClient.getTable();

            dbClient.setQuery("SELECT * FROM navigator_publics ORDER BY ordernum ASC");
            DataTable dPubItems = dbClient.getTable();

            if (dPrivCats != null)
            {
                PrivateCategories.Clear();
                foreach (DataRow Row in dPrivCats.Rows)
                {
                    PrivateCategories.Add((int)Row["id"], new FlatCat((int)Row["id"], (string)Row["caption"], (int)Row["min_rank"]));
                }
            }

            if (dPubItems != null)
            {
                PublicItems.Clear();
                foreach (DataRow Row in dPubItems.Rows)
                {
                    PublicItems.Add((int)Row["id"], new PublicItem((int)Row["id"], int.Parse(Row["bannertype"].ToString()), (string)Row["caption"], (string)Row["description"],
                        (string)Row["image"], ((Row["image_type"].ToString().ToLower() == "internal") ? PublicImageType.INTERNAL : PublicImageType.EXTERNAL),
                        Convert.ToUInt32(Row["room_id"]), (int)Row["category_id"], (int)Row["category_parent_id"], SilverwaveEnvironment.EnumToBool(Row["recommended"].ToString()), (int)Row["typeofdata"], (string)Row["tag"]));
                }
            }
        }

		internal void Init(IQueryAdapter DBClient)
		{
			this.Polls.Clear();
			DBClient.setQuery("SELECT * FROM polls WHERE enabled = '1'");
			DataTable table = DBClient.getTable();
			if (table != null)
			{
				foreach (DataRow dataRow in table.Rows)
				{
					uint num = uint.Parse(dataRow["id"].ToString());
					DBClient.setQuery("SELECT * FROM poll_questions WHERE poll_id = " + num);
					DataTable table2 = DBClient.getTable();
					List<PollQuestion> list = new List<PollQuestion>();
					foreach (DataRow dataRow2 in table2.Rows)
					{
						list.Add(new PollQuestion(uint.Parse(dataRow2["id"].ToString()), (string)dataRow2["question"], int.Parse(dataRow2["answertype"].ToString()), dataRow2["answers"].ToString().Split(new char[]
						{
							'|'
						}), (string)dataRow2["correct_answer"]));
					}
					Poll value = new Poll(num, uint.Parse(dataRow["room_id"].ToString()), (string)dataRow["caption"], (string)dataRow["invitation"], (string)dataRow["greetings"], (string)dataRow["prize"], int.Parse(dataRow["type"].ToString()), list);
					this.Polls.Add(num, value);
				}
			}
		}

        //internal void LoadRoles(DatabaseClient dbClient)
        //{
        //    ClearRoles();

        //    DataTable Data = dbClient.getTable("SELECT * FROM ranks ORDER BY id ASC;");

        //    if (Data != null)
        //    {
        //        foreach (DataRow Row in Data.Rows)
        //        {
        //            Roles.Add((uint)Row["id"], new Role((uint)Row["id"], (string)Row["name"]));
        //        }
        //    }
        //}

        internal void LoadRights(IQueryAdapter dbClient)
        {
            ClearRights();

            dbClient.setQuery("SELECT fuse, rank FROM fuserights;");
            DataTable Data = dbClient.getTable();

            dbClient.setQuery("SELECT fuse, sub FROM fuserights_subs;");
            DataTable SubData = dbClient.getTable();

            if (Data != null)
            {
                foreach (DataRow Row in Data.Rows)
                {
                    Rights.Add((string)Row["fuse"], Convert.ToUInt32(Row["rank"]));
                }
            }

            if (SubData != null)
            {
                foreach (DataRow Row in SubData.Rows)
                {
                    SubRights.Add((string)Row["fuse"], (string)Row["sub"]);
                }
            }
        }

        internal void LoadBots(IQueryAdapter dbClient)
        {
            Bots = new List<RoomBot>();

            dbClient.setQuery("SELECT id, room_id, ai_type, walk_mode, name, motto, look, x, y, z, rotation, min_x, min_y, max_x, max_y FROM bots;");
            DataTable Data = dbClient.getTable();

            dbClient.setQuery("SELECT id, bot_id, keywords, response_text, mode, serve_id FROM bots_responses;");
            DataTable BotResponses = dbClient.getTable();

            dbClient.setQuery("SELECT text, shout, bot_id FROM bots_speech;");
            DataTable BotSpeech = dbClient.getTable();

            List<BotResponse> Responses = new List<BotResponse>();
            List<RandomSpeech> Speeches = new List<RandomSpeech>();

            foreach (DataRow Row in BotResponses.Rows)
            {
                Responses.Add(new BotResponse(Convert.ToUInt32(Row["bot_id"]), (string)Row["keywords"], (string)Row["response_text"], Row["mode"].ToString(), (int)Row["serve_id"]));
            }

            foreach (DataRow Row in BotSpeech.Rows)
            {
                Speeches.Add(new RandomSpeech((string)Row["text"], ButterflyEnvironment.EnumToBool(Row["shout"].ToString()), Convert.ToUInt32(Row["bot_id"])));
            }

            if (Data == null)
            {
                return;
            }

            foreach (DataRow Row in Data.Rows)
            {
                string BotAI = (string)Row["ai_type"];
                AIType BotAIType;
                switch (BotAI)
                {
                    case "generic":
                        BotAIType = AIType.Generic;
                        break;
                    case "guide":
                        BotAIType = AIType.Guide;
                        break;
                    case "pet":
                        BotAIType = AIType.Pet;
                        break;
                    default:
                        BotAIType = AIType.Generic;
                        break;
                }

                Bots.Add(new RoomBot(Convert.ToUInt32(Row["id"]), Convert.ToUInt32(Row["room_id"]), BotAIType, (string)Row["walk_mode"],
                    (String)Row["name"], (string)Row["motto"], (String)Row["look"], (int)Row["x"], (int)Row["y"], (int)Row["z"],
                    (int)Row["rotation"], (int)Row["min_x"], (int)Row["min_y"], (int)Row["max_x"], (int)Row["max_y"], ref Speeches, ref Responses));
            }
        }

        internal static WiredLoaderObject LoadItem(RoomItem item, Room room, IQueryAdapter dbClient)
        {
            InteractionType type = item.GetBaseItem().InteractionType;
            List<RoomItem> items = null;
            if (NeedsFurnitures(type))
            {
                dbClient.setQuery("SELECT trigger_item FROM wired_to_item WHERE wired_id = " + item.Id);
                DataTable dTable = dbClient.getTable();
                RoomItem targetItem;
                items = new List<RoomItem>(5);
                foreach (DataRow dRows in dTable.Rows)
                {
                    targetItem = room.GetRoomItemHandler().GetItem(Convert.ToUInt32(dRows[0]));
                    if (targetItem == null || items.Contains(targetItem))
                    {
                        continue;
                    }

                    items.Add(targetItem);
                }
            }

            string[] settings = null;
            
            if(HasSettings(type))
            {
                settings = new string[4];
                dbClient.setQuery("SELECT data_one, data_two,data_three, data_four FROM wired_data WHERE wired_id = " + item.Id);

                DataRow dRow = dbClient.getRow();
                if (dRow != null)
                {
                    for (int i = 0; i < 4; i++)
                    {
                        settings[i] = dRow[i].ToString();
                    }
                }
                else
                {
                    settings = new string[] { "", "", "", "" };
                }
            }

            Dictionary<uint, OriginalItemLocation> originalPositionList = null;
            if (HasOriginalItemLocations(type))
            {
                originalPositionList = new Dictionary<uint, OriginalItemLocation>(5);
                dbClient.setQuery("SELECT item_id, original_x, original_y, rotation, height, extradata FROM wired_original_item_locations WHERE wired_id = " + item.Id);
                DataTable dTable = dbClient.getTable();
                foreach (DataRow dRows in dTable.Rows)
                {
                    originalPositionList.Add(uint.Parse(dRows[0].ToString()), new OriginalItemLocation(uint.Parse(dRows[0].ToString()), int.Parse(dRows[1].ToString()), int.Parse(dRows[2].ToString()), (double)Convert.ToDecimal(dRows[4]), int.Parse(dRows[3].ToString()), dRows[5].ToString()));
                }
            }
            return new WiredLoaderObject(items, originalPositionList, settings);
        }

		internal void LoadRights(IQueryAdapter dbClient)
		{
			this.ClearRights();
			dbClient.setQuery("SELECT command,rank FROM fuse_cmds;");
			DataTable table = dbClient.getTable();
			if (table != null)
			{
				foreach (DataRow dataRow in table.Rows)
				{
					if (!this.CMDRights.ContainsKey((string)dataRow[0]))
					{
						this.CMDRights.Add((string)dataRow[0], Convert.ToUInt32(dataRow[1]));
					}
					else
					{
						Logging.LogException(string.Format("Duplicate Fuse Command \"{0}\" found", dataRow[0]));
					}
				}
			}
			dbClient.setQuery("SELECT * FROM server_fuserights");
			DataTable table2 = dbClient.getTable();
			if (table2 != null)
			{
				foreach (DataRow dataRow2 in table2.Rows)
				{
					if ((int)dataRow2[3] == 0)
					{
						if (!this.Rights.ContainsKey((string)dataRow2[0]))
						{
							this.Rights.Add((string)dataRow2[0], Convert.ToUInt32(dataRow2[1]));
						}
						else
						{
							Logging.LogException(string.Format("Unknown Subscription Fuse \"{0}\" found", dataRow2[0]));
						}
					}
					else
					{
						if ((int)dataRow2[3] > 0)
						{
							this.SubRights.Add((string)dataRow2[0], (int)dataRow2[3]);
						}
						else
						{
							Logging.LogException(string.Format("Unknown fuse type \"{0}\" found", dataRow2[3]));
						}
					}
				}
			}
		}

        public static void UpdateInDatabase(IWiredTrigger wiredItem, IQueryAdapter dbClient)
        {
            RemoveFromDatabase(wiredItem, dbClient);

            RoomItem item = wiredItem.GetOriginalWiredItem();
            InteractionType type = item.GetBaseItem().InteractionType;

            if (WiredLoaderObject.HasSettings(type))
            {
                string[] data = (wiredItem as IWiredSettingsTrigger).GetSettings();
                dbClient.setQuery("INSERT INTO `wired_data` (`wired_id`, `data_one`, `data_two`, `data_three`, `data_four`) VALUES (@id, @data1, @data2, @data3, @data4) ");
                dbClient.addParameter("id", item.Id);
                dbClient.addParameter("data1", data.Length >= 1 ? data[0] : "");
                dbClient.addParameter("data2", data.Length >= 2 ? data[1] : "");
                dbClient.addParameter("data3", data.Length >= 3 ? data[2] : "");
                dbClient.addParameter("data4", data.Length >= 4 ? data[3] : "");
                dbClient.runQuery();
            }
            if (WiredLoaderObject.HasOriginalItemLocations(type))
            {
                Dictionary<uint, OriginalItemLocation> originalLoc = (wiredItem as IWiredOriginalItemTrigger).GetOriginalItemLocation();

                foreach (OriginalItemLocation itemLoc in originalLoc.Values)
                {
                    dbClient.setQuery("INSERT INTO `wired_original_item_locations` (`wired_id`,`item_id`, `original_x`, `original_y`, `rotation`, `extradata`, `height`) VALUES (@wid, @id, @orx, @ory, @orrot, @data, @height)");
                    dbClient.addParameter("wid", item.Id);
                    dbClient.addParameter("id", itemLoc.itemID);
                    dbClient.addParameter("orx", itemLoc.X);
                    dbClient.addParameter("ory", itemLoc.Y);
                    dbClient.addParameter("orrot", itemLoc.Rot);
                    dbClient.addParameter("data", itemLoc.ExtraData);
                    dbClient.addParameter("height", itemLoc.Height);

                    dbClient.runQuery();
                }
            }
            if (WiredLoaderObject.NeedsFurnitures(type))
            {
                List<RoomItem> items = (wiredItem as IWiredFurniTrigger).getAffectedItemList();
                foreach (RoomItem rItem in items)
                {
                    dbClient.setQuery("INSERT INTO `wired_to_item` (`wired_id`, `trigger_item`) VALUES (@id, @triggeritem)");
                    dbClient.addParameter("id", item.Id);
                    dbClient.addParameter("triggeritem", rItem.Id);
                    dbClient.runQuery();
                }
            }

        }

		internal void LoadBans(IQueryAdapter dbClient)
		{
			this.bannedUsernames.Clear();
			this.bannedIPs.Clear();
			this.bannedMachines.Clear();
			dbClient.setQuery("SELECT bantype,value,reason,expire FROM bans");
			DataTable table = dbClient.getTable();
			double num = (double)CyberEnvironment.GetUnixTimestamp();
			foreach (DataRow dataRow in table.Rows)
			{
				string text = (string)dataRow["value"];
				string reasonMessage = (string)dataRow["reason"];
				double num2 = (double)dataRow["expire"];
				string a = (string)dataRow["bantype"];
				ModerationBanType type;
				if (a == "user")
				{
					type = ModerationBanType.USERNAME;
				}
				else
				{
					if (a == "ip")
					{
						type = ModerationBanType.IP;
					}
					else
					{
						type = ModerationBanType.MACHINE;
					}
				}
				ModerationBan moderationBan = new ModerationBan(type, text, reasonMessage, num2);
				if (num2 > num)
				{
					if (moderationBan.Type == ModerationBanType.USERNAME)
					{
                        if (!this.bannedUsernames.Contains(text))
						{
							this.bannedUsernames.Add(text, moderationBan);
						}
					}
					else
					{
						if (moderationBan.Type == ModerationBanType.IP)
						{
                            if (!this.bannedIPs.Contains(text))
							{
								this.bannedIPs.Add(text, moderationBan);
							}
						}
						else
						{
							if (!this.bannedMachines.ContainsKey(text))
							{
								this.bannedMachines.Add(text, moderationBan);
							}
						}
					}
				}
			}
		}

        internal static void InitAchievementManager(IQueryAdapter dbClient)
        {
            dbClient.setQuery("SELECT achievements.*, achievement_categories.name " +
                                "FROM achievements " +
                                "JOIN achievement_categories " +
                                "ON achievement_categories.id = achievements.category");

            DataTable dTable = dbClient.getTable();

            achievements = new Dictionary<uint, AchievementBase>();

            uint achievementID;
            uint levels;
            uint badgelevel;
            string badge;
            int pixelBase;
            int pixelMMPORG;
            int pixelReward;
            string category;
            foreach (DataRow dRow in dTable.Rows)
            {
                achievementID = Convert.ToUInt32(dRow[0]);
                levels = Convert.ToUInt32(dRow[1]);
                badgelevel = Convert.ToUInt32(dRow[2]);
                badge = (string)dRow[3];
                pixelBase = (int)dRow[4];
                pixelMMPORG = (int)dRow[5];
                pixelReward = (int)dRow[6];
                category = (string)dRow[8];

                AchievementBase achivement = new AchievementBase(achievementID, levels, badgelevel, badge, pixelBase, pixelMMPORG, pixelReward, category);
                achievements.Add(achievementID, achivement);
            }
        }

 internal static void SaveTrigger(IQueryAdapter dbClient, int itemID, int triggetItemID)
 {
     dbClient.setQuery("INSERT INTO trigger_in_place (original_trigger,triggers_item) VALUES (@my_id,@trigger_item)");
     dbClient.addParameter("my_id", itemID);
     dbClient.addParameter("trigger_item", triggetItemID);
     dbClient.runQuery();
 }

        public Group(DataRow Data, IQueryAdapter dbClient)
        {
            this.ID = Convert.ToInt32(Data["id"]);
            this.Name = Data["name"].ToString();
            this.Description = Data["description"].ToString();
            this.DateCreated = Data["date_created"].ToString();
            this.OwnerID = Convert.ToInt32(Data["users_id"]);
            this.RoomID = Convert.ToInt32(Data["rooms_id"]);
            this.ColorID1 = Convert.ToInt32(Data["color1"]);
            this.ColorID2 = Convert.ToInt32(Data["color2"]);
            this.Type = Convert.ToInt32(Data["type"]);
            this.RightsType = Convert.ToInt32(Data["rights_type"]);

            // Parse badge data
            string[] rawData = Data["badge_data"].ToString().Split((char)1);
            List<Tuple<int, int, int>> badgeData = new List<Tuple<int,int,int>>();
            for (int i = 0; i < rawData.Length; i++)
            {
                int value1 = int.Parse(rawData[i++]);
                int value2 = int.Parse(rawData[i++]);
                int value3 = int.Parse(rawData[i]);
                badgeData.Add(new Tuple<int, int, int>(value1, value2, value3));
            }

            this.BadgeData = badgeData;
            this.Members = new List<int>();

            // Load members
            dbClient.setQuery("SELECT * FROM group_memberships WHERE groups_id = @id");
            dbClient.addParameter("id", ID);
            foreach (DataRow row in dbClient.getTable().Rows)
            {
                this.Members.Add((int)row["users_id"]);
            }
        }

        //internal void ClearCategories()
        //{
        //    Categories.Clear();
        //}

        internal void LoadTopics(IQueryAdapter dbClient)
        {
            Topics.Clear();
            DataTable TopicData = null;

            dbClient.setQuery("SELECT id, title, body, subject, known_issue FROM help_topics");
            TopicData = dbClient.getTable();

            if (TopicData == null)
            {
                return;
            }

            foreach (DataRow Row in TopicData.Rows)
            {
                HelpTopic NewTopic = new HelpTopic(Convert.ToUInt32(Row["id"]), (string)Row["title"], (string)Row["body"], Convert.ToUInt32(Row["subject"]));

                Topics.Add(Convert.ToUInt32(Row["id"]), NewTopic);

                int Importance = int.Parse(Row["known_issue"].ToString());

                if (Importance == 1)
                {
                    KnownIssues.Add(NewTopic);
                }
                else if (Importance == 2)
                {
                    ImportantTopics.Add(NewTopic);
                }
            }
        }

        internal static void Init(IQueryAdapter dbClient)
        {
            dbClient.setQuery("SELECT userpeak FROM server_status");
            UserPeak = dbClient.getInteger();

            _runFrequency = int.Parse(FirewindEnvironment.GetConfig().GetEntry("backgroundworker.interval", "10000")); // leon is crazy, 300!?! (THIS IS MADNESS!!)
        }

        private void ReloadQuests(IQueryAdapter dbClient)
        {
            quests.Clear();

            dbClient.setQuery("SELECT * FROM quests");
            DataTable dTable = dbClient.getTable();

            uint id;
            string category;
            int num;
            int type;
            uint goalData;
            string name;
            int reward;
            string dataBit;
            foreach (DataRow dRow in dTable.Rows)
            {
                id = Convert.ToUInt32(dRow["id"]);
                category = (string)dRow["category"];
                num = (int)dRow["series_number"];
                type = (int)dRow["goal_type"];
                goalData = Convert.ToUInt32(dRow["goal_data"]);
                name = (string)dRow["name"];
                reward = (int)dRow["reward"];
                dataBit = (string)dRow["data_bit"];

                Quest quest = new Quest(id, category, num, (QuestType)type, goalData, name, reward, dataBit);
                quests.Add(id, quest);
                AddToCounter(category);
            }
        }

        internal void InitGroups(IQueryAdapter dbClient)
        {
            dbClient.setQuery("SELECT * FROM groups_elements");
            DataTable table = dbClient.getTable();
            string type;

            foreach (DataRow row in table.Rows)
            {
                type = (string)row["Type"];
                GuildsPartsData data = new GuildsPartsData((int)row["Id"], (string)row["ExtraData1"], (string)row["ExtraData2"]);

                if (type == "Base")
                {
                    baseBadges.Add(data);
                }
                else if (data.ExtraData1.StartsWith("symbol_"))
                {
                    symbolBadges.Add(data);
                }
                else if (type == "Color1")
                {
                    colorBadges1.Add(data);
                }
                else if (type == "Color2")
                {
                    colorBadges2.Add(data);
                }
                else if (type == "Color3")
                {
                    colorBadges3.Add(data);
                    htmlBadges.Add(data.Id, data.ExtraData1);
                }
            }
        }