Works like :meth:`load_only` to provides a
:ref:`performance boost <increase-performance>` in cases when you need
to load all fields except a subset specified by *fields*.
162571
def dont_load(self, *fields):
        '''
'''
        q = self._clone()
        fs = unique_tuple(q.exclude_fields, fields)
        q.exclude_fields = fs if fs else None
        return q
13061
def _load(cls, attrs, *, context, **kwargs):
        
        return unpack_from_dynamodb(
            model=cls,
            attrs=attrs or {},
            expected=cls.Meta.columns,
            context=context, **kwargs)
341623
def load(self , filename=None, data=None):
        

        self.__load(filename=filename, data=data)
607951
def add(self, field, op=None, val=None):
        
        if field.has_subfield():
            self._fields[field.full_name] = 1
        else:
            self._fields[field.name] = 1
        if op and op.is_size() and not op.is_variable():
            # get minimal part of array with slicing,
            # but cannot use slice with variables
            self._slices[field.name] = val + 1
        if op and op.is_variable():
            # add the variable too
            self._fields[val] = 1
300821
def reload(self, *fields, **kw):
		""""""
		
		Doc, collection, query, options = self._prepare_find(id=self.id, projection=fields, **kw)
		result = collection.find_one(query, **options)
		
		if fields:  # Refresh only the requested data.
			for k in result:  # TODO: Better merge algorithm.
				if k == ~Doc.id: continue
				self.__data__[k] = result[k]
		else:
			self.__data__ = result
		
		return self
292125
public function alsoLoad($fields)
    {
        if(!is_array($fields))
        {
            $fields = [$fields];
        }

        foreach($fields as $field)
        {
            $this->mapping['alsoLoadFields'][] = $field;
        }

        return $this;
    }
650523
def deindex(self, values=None, only_index=None):
        
        assert self.indexable, "Field not indexable"
        assert not only_index or self.has_index(only_index), "Invalid index"
        if only_index:
            only_index = only_index if isclass(only_index) else only_index.__class__

        if values is None:
            values = self.proxy_get()
        for field_name, value in iteritems(values):
            if value is not None:
                for index in self._indexes:
                    if only_index and not isinstance(index, only_index):
                        continue
                    index.remove(field_name, value)
600108
def get_all(self, fields=list(), limit=None, order_by=list(), offset=None):
        """"""
        warnings.warn("get_all() is deprecated, please use get_multiple() instead", DeprecationWarning)
        return self.get_multiple(fields, limit, order_by, offset)
907048
def _bind_field(self, field_name, field_obj):
        
        try:
            if field_name in self.load_only:
                field_obj.load_only = True
            if field_name in self.dump_only:
                field_obj.dump_only = True
            field_obj._bind_to_schema(field_name, self)
            self.on_bind_field(field_name, field_obj)
        except TypeError:
            # field declared as a class, not an instance
            if (isinstance(field_obj, type) and
                    issubclass(field_obj, base.FieldABC)):
                msg = ('Field for "{}" must be declared as a '
                       'Field instance, not a class. '
                       'Did you mean "fields.{}()"?'
                       .format(field_name, field_obj.__name__))
                raise TypeError(msg)
1092132
def set_fields(self, fields=None, *fields_args, **fields_kwargs):
        
        if fields_args:
            fields = [fields]
            fields.extend(fields_args)
            for field_name in fields:
                self.set_field(field_name)

        elif fields_kwargs:
            fields = make_dict(fields, fields_kwargs)
            for field_name, field_val in fields.items():
                self.set_field(field_name, field_val)

        else:
            if isinstance(fields, Mapping):
                for field_name, field_val in fields.items():
                    self.set_field(field_name, field_val)

            else:
                for field_name in fields:
                    self.set_field(field_name)

        return self
813006
def _load_all(self):
        '''
        
        '''
        with self._lock:
            for name in self.file_mapping:
                if name in self.loaded_files or name in self.missing_modules:
                    continue
                self._load_module(name)

            self.loaded = True
197834
def st_only_cols dict
      (dict.keys.to_set - @only_cols).each{|col|dict.delete(col)}
      dict
    end
920959
def load(self, *relations):
        
        if len(self.items) > 0:
            query = self.first().new_query().with_(*relations)

            self._set_items(query.eager_load_relations(self.items))

        return self
1098528
def drop_all(self, **kwargs):
        
        conn = self.__get_conn__(**kwargs)
        conn.update_query("DROP ALL")
        self.loaded = []
        self.loaded_times = {}
1267924
def load(self, data):
        
        self.clear()
        self.update(data)
        self.enhance()
478083
def filter_excluded_fields(fields, Meta, exclude_dump_only):
    
    exclude = list(getattr(Meta, "exclude", []))
    if exclude_dump_only:
        exclude.extend(getattr(Meta, "dump_only", []))

    filtered_fields = OrderedDict(
        (key, value) for key, value in fields.items() if key not in exclude
    )

    return filtered_fields
325823
private boolean optimizeForInclusion(QuerySpec querySpec) {
        ResourceField idField = getIdField();
        return querySpec.getIncludedRelations().size() == 1 &&
                querySpec.getIncludedFields().size() == 1
                && idField.getUnderlyingName().equals(querySpec.getIncludedFields().get(0).getPath().toString());
    }