Load the documents from the database.

 @example Load the documents.
   cursor.load_docs

 @return [ Array<Hash> ] The documents.

 @since 1.0.0
165238
def load_docs
      @options[:flags] |= [:no_cursor_timeout] if @options[:no_timeout]
      options = @options.clone
      options[:limit] = request_limit

      reply, @node = read_preference.with_node(session.cluster) do |node|
        [ node.query(@database, @collection, @selector, query_options(options)), node ]
      end

      @limit -= reply.count if limited?
      @cursor_id = reply.cursor_id
      reply.documents
    end
1038307
private function loadStores()
    {
        $itemIds = array_keys($this->_items);

        if (count($itemIds)) {
            $connection = $this->getConnection();
            $select = $connection->select()
                ->from(['thesaurus_entity_store' => $this->getTable(ThesaurusInterface::STORE_TABLE_NAME)])
                ->where('thesaurus_entity_store.' . ThesaurusInterface::THESAURUS_ID . ' IN (?)', $itemIds);

            $result = $connection->fetchPairs($select);

            if ($result) {
                foreach ($this as $item) {
                    $entityId = $item->getData(ThesaurusInterface::THESAURUS_ID);
                    if (!isset($result[$entityId])) {
                        continue;
                    }
                    $storeId = $result[$item->getData(ThesaurusInterface::THESAURUS_ID)];
                    $storeCode = $this->storeManager->getStore($storeId)->getCode();

                    if ($result[$entityId] == 0) {
                        $stores = $this->storeManager->getStores(false, true);
                        $storeId = current($stores)->getId();
                        $storeCode = key($stores);
                    }

                    $item->setData('_first_store_id', $storeId);
                    $item->setData('store_code', $storeCode);
                    $item->setData('store_id', [$result[$entityId]]);
                }
            }
        }
    }
718841
def load(self):
        

        filters = [Filter(self.field, 'eq', self.rid)]
        store = goldman.sess.store

        self._is_loaded = True
        self.models = store.search(self.rtype, filters=filters)

        return self.models
1157175
def get_documents_in_collection(self, collection_name, with_id=True):
        
        documents_iterator = self.database[collection_name].find()  # anything
        documents = [
            d for d in documents_iterator
        ]  # list of all documents in collection in database

        if not with_id:
            for doc in documents:
                doc.pop("_id")  # remove id key

        return documents
1348664
def load(self, indexables):
        
        try:
            data = Persistence.read(self.path, create_file=True)
        except ValueError:
            data = {}

        return self.load_data(data, indexables)
1222716
def results
      ActiveRecord::Base.connection.tables.each do |table|
        model = table.classify.constantize rescue next

        model.columns.each do |column|
          present = model.respond_to?(:nillify_attributes) && model.nillify_attributes.include?(column.name.to_sym)

          @results << [present, model.name, column.name] if include_column(column)
        end
      end

      @results
    end
399791
def load(attributes)
      raise ArgumentError, "expected an attributes Hash, got #{attributes.inspect}" unless attributes.is_a?(Hash)
      @prefix_options, attributes = split_options(attributes)
      attributes.each do |key, value|
        @attributes[key.to_s] = typecast_attribute_value(key, value)
      end
      self
    end
30926
protected function load()
    {
        $tables = $this->fetchTables($this->schema);
        foreach ($tables as $table) {
            $this->loadTable($table);
        }
        $views = $this->fetchViews($this->schema);
        foreach ($views as $table) {
            $this->loadTable($table, true);
        }
    }
1349348
def documents(cls, filter=None, **kwargs):
        
        documents = [cls(document) for document in cls.find(filter, **kwargs)]
        return [document for document in documents if document.document]
328062
def load
      if loaded? || limit_value.nil?
        super
      else
        @values[:limit] = limit_value + 1
        # FIXME: this could be removed when we're dropping AR 4 support
        @arel.limit = @values[:limit] if @arel && (Integer === @arel.limit)
        super
        @values[:limit] = limit_value - 1
        # FIXME: this could be removed when we're dropping AR 4 support
        @arel.limit = @values[:limit] if @arel && (Integer === @arel.limit)

        if @records.any?
          @records = @records.dup if (frozen = @records.frozen?)
          @_has_next = !!@records.delete_at(limit_value)
          @records.freeze if frozen
        end

        self
      end
    end
95895
def get_entities(self):
        
        try:
            return self.__dict__['entities']
        except KeyError:
            entities = self._connection.fetch(
                "documents/%s/entities.json" % self.id
            ).get("entities")
            obj_list = []
            for type, entity_list in list(entities.items()):
                for entity in entity_list:
                    entity['type'] = type
                    obj = Entity(entity)
                    obj_list.append(obj)
            self.__dict__['entities'] = obj_list
            return self.__dict__['entities']
714265
def load_associated_collections
      array = association_fields

      if array.map{|f| f.collection_loaded?}.include?(false)
        StorageRoom.log("Fetching associated collections for '#{name}'")
        array.each{|f| f.collection}
      end
    end
88853
def load_files(file_finder)
      if file_finder.options.fetch(:files).empty?
        file_finder.list(*options[:extensions])
      else
        file_finder.options.fetch(:files) { [] }
      end
    end
1133419
protected boolean _load ()
    {
    	java.util.ArrayList newChildren = new java.util.ArrayList();

    	/* @todo make this work */
//    	if (cld.getConnectionDescriptor() != null)
//    	{
//    		newChildren.add(new OjbMetaJdbcConnectionDescriptorNode(
//    			this.getOjbMetaTreeModel().getRepository(),
//    			this.getOjbMetaTreeModel(),
//    			this,
//    			cld.getConnectionDescriptor()));
//    	}
//
    	// Add collection descriptors
    	java.util.Iterator it = cld.getCollectionDescriptors().iterator();
    	while (it.hasNext())
    	{
    		CollectionDescriptor collDesc = (CollectionDescriptor)it.next();
    		newChildren.add(new OjbMetaCollectionDescriptorNode(
    			this.getOjbMetaTreeModel().getRepository(),
    			this.getOjbMetaTreeModel(),
    			this,
    			collDesc));

    	}

    	// Add extent classes Class

        it = cld.getExtentClassNames().iterator();
    	while (it.hasNext())
    	{
    		String extentClassName = (String)it.next();
    		newChildren.add(new OjbMetaExtentClassNode(
    			this.getOjbMetaTreeModel().getRepository(),
    			this.getOjbMetaTreeModel(),
    			this,
    			extentClassName));

    	}

        // Get Field descriptors FieldDescriptor
        if (cld.getFieldDescriptions() != null)
        {
            it = new ArrayIterator(cld.getFieldDescriptions());
            while (it.hasNext())
            {
                FieldDescriptor fieldDesc = (FieldDescriptor)it.next();
                newChildren.add(new OjbMetaFieldDescriptorNode(
                        this.getOjbMetaTreeModel().getRepository(),
                        this.getOjbMetaTreeModel(),
                        this,
                        fieldDesc));
            }
        }
        else
        {
                System.out.println(cld.getClassNameOfObject() + " does not have field descriptors");
        }

        // Get Indices IndexDescriptor
        it = cld.getIndexes().iterator();
    	while (it.hasNext())
    	{
    		IndexDescriptor indexDesc = (IndexDescriptor)it.next();
    		newChildren.add(new OjbMetaIndexDescriptorNode(
    			this.getOjbMetaTreeModel().getRepository(),
    			this.getOjbMetaTreeModel(),
    			this,
    			indexDesc));

    	}

    	// Get references ObjectReferenceDescriptor
    	it = cld.getObjectReferenceDescriptors().iterator();
    	while (it.hasNext())
    	{
    		ObjectReferenceDescriptor objRefDesc = (ObjectReferenceDescriptor)it.next();
    		newChildren.add(new OjbMetaObjectReferenceDescriptorNode(
    			this.getOjbMetaTreeModel().getRepository(),
    			this.getOjbMetaTreeModel(),
    			this,
    			objRefDesc));

    	}
    	// Add
    	this.alChildren = newChildren;
    	this.getOjbMetaTreeModel().nodeStructureChanged(this);
        return true;
    }
254252
def get_documents(self):
        
        return self.session.query(Document).order_by(Document.name).all()
790075
def each
      @dir.synchronize do
        ensure_reader_open
        (0...@reader.max_doc).each do |i|
          yield @reader[i].load unless @reader.deleted?(i)
        end
      end
    end
620075
protected function load_groups() {
        global $DB;

        $groupids = [];
        foreach ($this->events as $event) {
            if ($group = $event->get_group()) {
                $id = $group->get('id');
                $groupids[$id] = true;
            }
        }

        if (empty($groupids)) {
            $this->groups = [];
            return;
        }

        list($idsql, $params) = $DB->get_in_or_equal(array_keys($groupids));
        $sql = "SELECT * FROM {groups} WHERE id {$idsql}";

        $this->groups = $DB->get_records_sql($sql, $params);
    }