public PrimitiveApplicationInfo(Core core, Primitive owner, long applicationId)
            : base(core)
        {
            this.owner = owner;
            ItemLoad += new ItemLoadHandler(PrimitiveApplicationInfo_ItemLoad);

            SelectQuery query = new SelectQuery(PrimitiveApplicationInfo.GetTable(typeof(PrimitiveApplicationInfo)));
            query.AddFields(PrimitiveApplicationInfo.GetFieldsPrefixed(core, typeof(PrimitiveApplicationInfo)));
            query.AddCondition("application_id", applicationId);
            query.AddCondition("item_id", owner.Id);
            query.AddCondition("item_type_id", owner.TypeId);

            DataTable appDataTable = db.Query(query);

            if (appDataTable.Rows.Count == 1)
            {
                DataRow appRow = appDataTable.Rows[0];
                try
                {
                    loadItemInfo(appRow);
                }
                catch (InvalidItemException)
                {
                    throw new InvalidPrimitiveAppInfoException();
                }
            }
            else
            {
                throw new InvalidPrimitiveAppInfoException();
            }
        }

        public EventEmailInvite(Core core, DataRow eventInviteDataRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(EventEmailInvite_ItemLoad);

            loadItemInfo(eventInviteDataRow);
        }

        public InviteKey(Core core, DataRow inviteRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(InviteKey_ItemLoad);

            loadItemInfo(inviteRow);
        }

        public RateLimit(Core core, System.Data.Common.DbDataReader rateLimitRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(RateLimit_ItemLoad);

            loadItemInfo(rateLimitRow);
        }

        internal GroupOperator(Core core, DataRow operatorRow)
            : base(core, operatorRow)
        {
            ItemLoad += new ItemLoadHandler(GroupOperator_ItemLoad);

            loadItemInfo(operatorRow);
        }

        public ActionItem(Core core, long actionId, long itemId, long itemTypeId)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(ActionItem_ItemLoad);

            SelectQuery query = ActionItem.GetSelectQueryStub(core, typeof(ActionItem));
            query.AddCondition("action_id", actionId);
            query.AddCondition("item_id", itemId);
            query.AddCondition("item_type_id", itemTypeId);

            System.Data.Common.DbDataReader actionReader = db.ReaderQuery(query);

            if (actionReader.HasRows)
            {
                actionReader.Read();

                loadItemInfo(actionReader);

                actionReader.Close();
                actionReader.Dispose();
            }
            else
            {
                actionReader.Close();
                actionReader.Dispose();

                throw new InvalidActionItemException();
            }
        }

        public Calendar(Core core, Primitive owner)
            : base(core)
        {
            if (core == null)
            {
                throw new NullCoreException();
            }

            if (owner == null)
            {
                throw new InvalidUserException();
            }

            this.owner = owner;
            ItemLoad += new ItemLoadHandler(Calendar_ItemLoad);

            try
            {
                LoadItem("calendar_item_id", "calendar_item_type_id", owner);
            }
            catch (InvalidItemException)
            {
                throw new InvalidCalendarException();
            }
        }

        public GuestBookCommentCount(Core core, DataRow countRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(GuestBookCommentCount_ItemLoad);

            loadItemInfo(countRow);
        }

        public ApplicationError(Core core, System.Data.Common.DbDataReader errorRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(ApplicationError_ItemLoad);

            loadItemInfo(errorRow);
        }

        public Category(Core core, DataRow categoryRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(Category_ItemLoad);

            loadItemInfo(categoryRow);
        }

        public SpamReport(Core core, DataRow reportRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(SpamReport_ItemLoad);

            loadItemInfo(reportRow);
        }

        public HelpTopic(Core core, DataRow helpRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(HelpTopic_ItemLoad);

            loadItemInfo(helpRow);
        }

        public ReferralKey(Core core, DataRow referralRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(ReferralKey_ItemLoad);

            loadItemInfo(referralRow);
        }

        public ItemViewCountByHour(Core core, DataRow viewRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(ItemViewCountByHour_ItemLoad);

            loadItemInfo(viewRow);
        }

        public ItemHashtag(Core core, DataRow itemHashtagRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(ItemHashtag_ItemLoad);

            loadItemInfo(itemHashtagRow);
        }

        public ListType(Core core, DataRow typeRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(ListType_ItemLoad);

            loadItemInfo(typeRow);
        }

        public ListItem(Core core, DataRow listItemRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(ListItem_ItemLoad);

            loadItemInfo(listItemRow);
            lit = new ListItemText(core, listItemRow);
        }

        public FriendGroup(Core core, User owner, DataRow friendGroupRow)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(FriendGroup_ItemLoad);
            this.owner = owner;

            loadItemInfo(friendGroupRow);
        }

        internal GroupOfficer(Core core, System.Data.Common.DbDataReader officerRow)
            : base(core, officerRow)
        {
            ItemLoad += new ItemLoadHandler(GroupOfficer_ItemLoad);

            loadItemInfo(officerRow);
            loadGroupMember(officerRow);
            loadUser(officerRow);
        }

        public Currency(Core core, long currencyId)
            : base(core)
        {
            ItemLoad += new ItemLoadHandler(Currency_ItemLoad);

            this.currencyId = currencyId;

            GetCurrencyInfo(currencyId, ref currencyCode, ref title, ref fraction, ref symbol);
        }