一种方法可以检索所有数据，或者几种较小的方法可以检索每个部分？

Question

I have several doubts about OOP PHP code I'm creating. It is (so far) for retrieving a title and several chapters in different languages stored online. But first I will show the code as my doubts refer to this. This is the class I'm currently working with:

<?php
// Requires PHP 5.4+
class Subject
  {
  private $DB;
  private $Language;
  private $Keyword;

  public function __construct($DB, $Keyword, $Language)
    {
    $this->DB=$DB;
    $this->Keyword=$Keyword;
    $this->Language=$Language;
    }

  private function query($query, $arg)
    {
    $STH = $this->DB->prepare($query);
    $STH->execute(array_merge((array)$this->Keyword, (array)$arg));
    return $STH->fetch()[$this->Language];  // PHP 5.4+
    }

  public function retrieveTitle ()
    {
    return $this->query("SELECT * FROM subject WHERE keyword = ? ORDER BY date DESC LIMIT 1");
    }

  public function retrieveChapter ($arg)
    {
    return $this->query("SELECT * FROM chapters WHERE subject_keyword = ? AND type = ? ORDER BY date DESC LIMIT 1", $arg);
    }
?>

Then I do something similar to this to display the page:

if (isset($_GET['a']))
  {
  $Subject=new Subject($DB, $_GET['a'], $User->get('language'));

  if ($Subject->retrieveTitle())
    {
    echo '<h1 id="Title">'.$Subject->retrieveTitle().'</h1>';

    // Index
    if ($Subject->retrieveTitle())
      // ... code for the index

    // Introduction
    if ($Subject->retrieveChapter('Introduction'))
      echo '<h2 id="Introduction">' . $_('Introduction') . '</h2>' . $Subject->retrieveChapter('Introduction');

    // ... more non-relevant code.
    }
  }
else
  // ... whatever

First concern. I'm not sure if this is the proper way to handle this kind of data. I tried to separate the methods and make them as small as possible, trying also not to repeat much code. And this is the way that feels right. But I cannot see why this other code, similar to the previous one, is less desirable. Note: This class has SURELY some typos and has not been tested, it's only here to ilustrate the difference, so please don't use it (at least not literaly):

<?php
// Requires PHP 5.4+
class Subject
  {
  public $Title;
  public $Chapters = array ();

  public function __construct($DB, $Keyword, $Language)
    {
    // Retrieve all
    $STH = $DB->prepare("SELECT * FROM subject WHERE keyword = ? ORDER BY date DESC LIMIT 1");
    $STH->execute(array($Keyword));
    $this->Title = $STH->fetch()[$Language];  // PHP 5.4+

    // Retrieve chapters
    $ToForeach = ('Introduction','History','1');
    $STH = $DB->prepare("SELECT * FROM chapters WHERE subject_keyword = ? AND type = ? ORDER BY date DESC LIMIT 1");
    foreach ($ToForeach as $part)
      {
      $STH->execute(array($Keyword, $part));
      $this->Chapters = $STH->fetch()[$Language];
      }
    }
  }
?>

And then access the properties directly (or even build some get() in the middle, but you get the idea).

So, is there any difference? What are the benefits and pitfalls of the first method vs the second to code the class? Memory usage should be slightly smaller in the first one, but I think that won't be a deal breaker in comparison to readability in this case.

EDIT: Just writing the question in a way for others to understand has lead me to think about it in other ways. The first way also looks easier to test.

Second concern. If I want to make a/some methods for saving data, should I put it in the same class or in a different one? Because if I put it in one it bundles all the subject related methods in one pretty independent class, if I separate it I have more specialized classes with separated roles.

Any further advice, specifically about coding best practices [that I might not be following], is also welcome!

Answer 1

This is not easy to answer in a good way. So I can only focus on some minor parts of it. For not repeating code, I'd say the first example you give has quite some repeated code:

class Subject
{
    /**
     * @var ParametrizedQueryFetchQueryFactory
     */
    private $queryFactory;

    public function __construct($DB, $Keyword, $Language) {

        $this->queryFactory = new ParametrizedQueryFetchQueryFactory($DB, $Language, [$Keyword]);
    }

    private function query($query, array $args = array()) {
        return $this->queryFactory->query($query, $args);
    }

    public function retrieveTitle() {

        return $this->query("SELECT * FROM subject WHERE keyword = ? ORDER BY DATE DESC LIMIT 1");
    }

    public function retrieveChapter($part) {
        return $this->query(
            "SELECT * FROM chapters WHERE subject_keyword = ? AND TYPE = ? ORDER BY DATE DESC LIMIT 1",
            [$part]
        );
    }
}

class ParametrizedQueryFetchQueryFactory
{
    private $db, $returnIndex, $defaultArgs;

    public function __construct($db, $returnIndex, array $defaultArgs = array()) {
        $this->db = $db;
        $this->returnIndex = $returnIndex;
        $this->defaultArgs = $defaultArgs;
    }

    public function query($query, array $args = array()) {
        $fetcher = new ParametrizedQueryFetch($this->db,$query, $this->returnIndex, $this->defaultArgs);
        return $fetcher->execute($args);
    }
}

class ParametrizedQueryFetch
{
    private $db, $query, $returnIndex, $defaultArgs;
    public function __construct($db, $query, $returnIndex, array $defaultArgs = array()) {
        $this->db = $db;
        $this->query = $query;
        $this->returnIndex = $returnIndex;
        $this->defaultArgs = $defaultArgs;
    }

    public function execute(array $args) {
        $args = array_merge($this->defaultArgs, $args);
        $stmt = $this->db->prepare($this->query);
        $stmt->excute($args);
        return $stmt->fetch()[$this->returnIndex];
    }
}

And btw, to make this PHP 5.3 compatible, you would only need to change a single line here.