def _load_multi(cls, need):
        need = tup(need)
        need_ids = [n._id for n in need]
        datas = cls._get_data(cls._type_id, need_ids)
        to_save = {}
        try:
            essentials = object.__getattribute__(cls, "_essentials")
        except AttributeError:
            essentials = ()

        for i in need:
            #if there wasn't any data, keep the empty dict
            i._t.update(datas.get(i._id, i._t))
            i._loaded = True

            for attr in essentials:
                if attr not in i._t:
                    print "Warning: %s is missing %s" % (i._fullname, attr)
            i._asked_for_data = True
            to_save[i._id] = i

        prefix = thing_prefix(cls.__name__)

        #write the data to the cache
        cache.set_multi(to_save, prefix=prefix)

    def _load_multi(cls, need):
        need = tup(need)
        need_ids = [n._id for n in need]
        datas = cls._get_data(cls._type_id, need_ids)
        to_save = {}
        for i in need:
            #if there wasn't any data, keep the empty dict
            i._t.update(datas.get(i._id, i._t))
            i._loaded = True
            to_save[i._id] = i

        prefix = thing_prefix(cls.__name__)

        #avoid race condition when incrementing data int props by
        #putting all the int props into the cache.

        #prop prefix
        def pp(prop, id):
            return prop + '_' + str(i._id)

        #do defined data props first, this also checks default values
        for prop in cls._data_int_props:
            for i in need:
                to_save[pp(prop, i._id)] = getattr(i, prop)

        #int props based on the suffix
        for i in need:
            for prop, val in i._t.iteritems():
                if cls._int_prop_suffix and prop.endswith(cls._int_prop_suffix):
                    to_save[pp(prop, i._id)] = val

        cache.set_multi(to_save, prefix)

    def ratelimit(self, rate_user = False, rate_ip = False, prefix = "rate_"):
        to_set = {}
        seconds = g.RATELIMIT*60
        expire_time = datetime.now(g.tz) + timedelta(seconds = seconds)
        if rate_user and c.user_is_loggedin:
            to_set['user' + str(c.user._id36)] = expire_time
        if rate_ip:
            to_set['ip' + str(request.ip)] = expire_time

        cache.set_multi(to_set, prefix, time = seconds)

        def items_db(ids):
            items = cls._get_item(cls._type_id, ids)
            for i in items.keys():
                items[i] = cls._build(i, items[i])

            #avoid race condition when incrmenting int props (data int
            #props are set in load_multi)
            for prop in cls._int_props:
                keys = dict((i, getattr(item, prop))
                            for i, item in items.iteritems())
                cache.set_multi(keys, prefix + prop + '_' )

            return items

    def _load_multi(cls, need):
        need = tup(need)
        need_ids = [n._id for n in need]
        datas = cls._get_data(cls._type_id, need_ids)
        to_save = {}
        for i in need:
            #if there wasn't any data, keep the empty dict
            i._t.update(datas.get(i._id, i._t))
            i._loaded = True
            to_save[i._id] = i

        prefix = thing_prefix(cls.__name__)

        #write the data to the cache
        cache.set_multi(to_save, prefix=prefix)