Sinn des Repository in einer Extension ist es, Daten aus der Datenbank holen, schreiben oder bearbeiten. Neben dem bisherigen QueryResultInterface gab es im Repository stets die Möglichkeit, Datenbanken direkt mit SQL-Code abzufragen. Dies ist mit der LTS 9 von TYPO3 nicht mehr möglich. Entsprechende Abfragen müssen umgeschrieben werden. Für den Fall des IBK Blogs habe ich diese exemplarisch durchgezogen. Der Aufwand lohnt sich, denn man erhält nicht nur bessere Fehlermeldungen bei Fehlern in der SQL-Syntax, der Code wird auch strukturierter und leichter durchschaubar.

Über das QueryInterface werden Anfragen an die Datenbank gestellt.

public function findAllBlogs()
{
  $query = $this->createQuery();
  $result = $query->execute();
  return $result;
}

public function findOrderedBlogs()
{
  $query = $this->createQuery();
  $query->setOrderings(array(
    'datum' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_DESCENDING
  ));
  $result = $query->execute();
  return $result;
}
  

Wichtige Parameter bei dieser Funktion:

• Übergabe von Parametern
• Ordering nach Parameter
• Offset nach Parameter

public function findBlogs($blogLimit, $blogOffset)
{
  $query = $this->createQuery();
  $query->setOrderings(array(
    'datum' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_DESCENDING
  ));
  $query->setLimit(intval($blogLimit));
  $query->setOffset(intval($blogOffset));
  $result = $query->execute();
  return $result;
}

/**
 * Find all posts with a distinct Kategorie
 * 
 * @param int $katid   UID for Kategorie
 * @param int $limit   How many posts should be found.
 * @param int $offset  Where the search should start
 * @return \TYPO3\CMS\Extbase\Persistence\QueryResultInterface
 */
public function findByKategorie($katid, $limit, $offset)
{
  $query = $this->createQuery();
  $query->matching($query->equals('kategorie', $katid));
  $query->setLimit(intval($limit));
  $query->setOffset(intval($offset));
  $query->setOrderings(array(
    'datum' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_DESCENDING
  ));
  $result = $query->execute();
  return $result;
}

/**
 * Find all posts with a title or content which contains the specified search word.
 * 
 * @param string $searchWord     Search word to look for.
 * @param int    $limit          How many posts should be found.
 * @param int    $offset         Where the search should start
 * @return \TYPO3\CMS\Extbase\Persistence\QueryResultInterface
 */
public function findBySearch($searchWord, $limit, $offset)
{
  $query = $this->createQuery();
  $query->matching(
    $query->logicalOr(
      $query->like('titel', '%' . $searchWord . '%'), 
      $query->like('kurzfassung', '%' . $searchWord . '%'), 
      $query->like('inhalt', '%' . $searchWord . '%')
    )
  );
  $query->setLimit(intval($limit));
  $query->setOffset(intval($offset));
  $query->setOrderings(array(
    'datum' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_DESCENDING
  ));
  $result = $query->execute();
  return $result;
}

public function getBlogKategorienCounter($katid)
{
  $query = $this->createQuery();
  $query->matching($query->equals('kategorie', $katid));
  $result = $query->execute()->count();
  return $result;
}

Sortierung in absteigender Reihenfolge:

$query->setOrderings(array(
  'datum' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_DESCENDING
));

Sortierung in aufsteigender Reihenfolge:

$query->setOrderings(array(
  'datum' => \TYPO3\CMS\Extbase\Persistence\QueryInterface::ORDER_ASCENDING
));  

Ab der LTS 9 von TYPO3 werden SQL Anfragen an die Datenbank über diese Klasse gemacht.

Einbindung des ConnectionPool:

<?php
namespace Ibk\Ibkblog\Domain\Repository;

use TYPO3\CMS\Core\Utility\GeneralUtility;
use TYPO3\CMS\Core\Database\ConnectionPool;  

public function getBlogKategorienName($katid)
{
  $table = "tx_ibkblog_domain_model_kategorie";
  $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
  $katNameArray = $queryBuilder ->select('name')
    ->from($table)
    ->where(
      $queryBuilder->expr()->eq('uid', $queryBuilder->createNamedParameter($katid, \PDO::PARAM_INT))
    )
    ->execute()
    ->fetchAll();
    
  $katName = $katNameArray['name'];
  return $katName;
}

Wichtige Elemente dieser Funktion:

• Kreuztabellenabfrage mit Join über zwei Felder
• Ordering in aufsteigender Reihenfolge
• Gruppierung von Ergebnissen
• Zähler für gruppierte Ergebnisse
• Volltextsuche mit auskommentierten „%“ der SQL-Syntax

public function tagShow($pid)
{
  $tagShowArray = [];
  $table = "tx_ibkblog_domain_model_tag";
  $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
     
  $tagShowArray = $queryBuilder 
    ->select('tx_ibkblog_domain_model_tag.uid', 'tx_ibkblog_domain_model_tag.name')
    ->addSelectLiteral(
      $queryBuilder->expr()->count('tx_ibkblog_domain_model_tag.name', 'counter')
    )
    ->from('tx_ibkblog_domain_model_tag')
    ->join(
      'tx_ibkblog_domain_model_tag',
      'tx_ibkblog_blog_tag_mm',
      'tx_ibkblog_blog_tag_mm',
      $queryBuilder->expr()->eq(
        'tx_ibkblog_domain_model_tag.uid', 
        $queryBuilder->quoteIdentifier('tx_ibkblog_blog_tag_mm.uid_foreign')
      )
    )
    ->where(
      $queryBuilder->expr()->eq(
        'tx_ibkblog_domain_model_tag.pid', 
        $queryBuilder->createNamedParameter($pid, \PDO::PARAM_INT)
      )
    )
    ->orderBy('tx_ibkblog_domain_model_tag.name', 'ASC')            
    ->groupBy('tx_ibkblog_domain_model_tag.uid')            
    ->execute()
    ->fetchAll();
      
  return $tagShowArray;
}
  

Wie man an diesem Beispiel sieht: Die Nutzung der ConnectionPool Klasse bringt einen sehr strukturierten Code mit sich, anhand dessen man Monate nach dem Schreiben der Abfrage recht schnell versteht, was diese Funktion leistet.

Für die Bildergalerie auf der Georgienseite benötigen wir für eine Filterung nach Tags eine Kreuztabellenabfrage. Bilder und Tags stehen in einer n:m Beziehung zueinander. Entsprechend müssen die vorhandenen Tags und ihre Verknüpfung abgefragt werden.

$tagArray = [];
$table = "tx_ibkbilder_domain_model_tag";
$queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);

$tagArray = $queryBuilder 
  ->select('tx_ibkbilder_domain_model_tag.tag', 
    'tx_ibkbilder_bilder_tag_mm.uid_local', 
    'tx_ibkbilder_bilder_tag_mm.uid_foreign', 
    'tx_ibkbilder_domain_model_bilder.uid', 
    'tx_ibkbilder_domain_model_bilder.bildergalerie')
  ->from('tx_ibkbilder_domain_model_tag')
  ->from('tx_ibkbilder_bilder_tag_mm')
  ->from('tx_ibkbilder_domain_model_bilder')
  ->where(
    $queryBuilder->expr()->eq(
      'tx_ibkbilder_bilder_tag_mm.uid_local', 
      $queryBuilder->quoteIdentifier('tx_ibkbilder_domain_model_bilder.uid')
    )
  )
  ->andWhere(
    $queryBuilder->expr()->eq(
      'tx_ibkbilder_domain_model_tag.uid', 
      $queryBuilder->quoteIdentifier('tx_ibkbilder_bilder_tag_mm.uid_foreign')
    )
  )
  ->andWhere(
    $queryBuilder->expr()->eq(
      'tx_ibkbilder_domain_model_bilder.bildergalerie', 
      $queryBuilder->createNamedParameter($bildergalerie, \PDO::PARAM_INT)
    )
  )
  ->orderBy('tx_ibkbilder_domain_model_tag.tag', 'ASC')            
  ->groupBy('tx_ibkbilder_domain_model_tag.tag')            
  ->execute()
  ->fetchAll();

/**
 * Find number of all posts with a title or content which contains the specified search word.
 * 
 * @param string $searchWord Search word to look for.
 * @return \TYPO3\CMS\Extbase\Persistence\QueryResultInterface
 */
public function findNumberBySearch($searchWord)
{
  $table = "tx_ibkblog_domain_model_blog";
  $queryBuilder = GeneralUtility::makeInstance(ConnectionPool::class)->getQueryBuilderForTable($table);
  $idArray = $queryBuilder ->select('uid')
    ->from($table)
    ->orWhere(
      $queryBuilder->expr()->like(
        'titel', 
        $queryBuilder->createNamedParameter('%' . $queryBuilder->escapeLikeWildcards($searchWord) . '%')
      ),
      $queryBuilder->expr()->like(
        'kurzfassung', 
        $queryBuilder->createNamedParameter('%' . $queryBuilder->escapeLikeWildcards($searchWord) . '%')
      ),
      $queryBuilder->expr()->like(
        'inhalt', 
        $queryBuilder->createNamedParameter('%' . $queryBuilder->escapeLikeWildcards($searchWord) . '%')
      )
    )
    ->execute()
    ->fetchAll();        
         
  return $idArray;
}  

Bei dieser Funktion kommen mehrere Methoden des ConnectionPool zum Einsatz. Nach Stand September 2018 der TYPO3 Version 9 DEV sollen Verbindungen nicht wiederverwendet werden. Daher wird hier für jede Anfrage an die Datenbank eine neue Instanz des ConnectionPool initialisiert.

public function saveBlogKommentar($kommentar, $blog)
{
  $message = 'Der Beitrag wurde gespeichert';
  $queryName = $kommentar->getName();
  $queryEmail = $kommentar->getEmail();
  $queryKommentar = $kommentar->getKommentar();
  $queryDatum = $kommentar->getDatum();
  $queryPid = $kommentar->getPid();
  $pos = strrpos($blog, ':') + 1;
  $queryBlog = intval(substr($blog, $pos));
  
  ## Kommentar zu einem Beitrag speichern
  $queryBuilder1 = GeneralUtility::makeInstance(ConnectionPool::class)
    ->getQueryBuilderForTable('tx_ibkblog_domain_model_kommentar');
  $save1 = $queryBuilder1
    ->insert('tx_ibkblog_domain_model_kommentar')
    ->values([
      'name' => $queryName, 
      'email' => $queryEmail, 
      'kommentar' => $queryKommentar, 
      'blog' => $queryBlog, 
      'datum' => $queryDatum, 
      'pid' => $queryPid,
    ])
    ->execute();
    
  ## Anzahl bisheriger Kommentare auslesen und um 1 erhöhen
  $queryBuilder2 = GeneralUtility::makeInstance(ConnectionPool::class)
    ->getQueryBuilderForTable('tx_ibkblog_domain_model_blog');        
  $save2 = $queryBuilder2 ->select('uid')
    ->from('tx_ibkblog_domain_model_blog')
    ->where(
      $queryBuilder2->expr()->eq('uid', $queryBuilder2->createNamedParameter($queryBlog, \PDO::PARAM_INT))
    )
    ->setMaxResults(1)
    ->execute()
    ->fetchAll();
      
  $queryBuilder3 = GeneralUtility::makeInstance(ConnectionPool::class)
    ->getQueryBuilderForTable('tx_ibkblog_domain_model_blog');                
  $kommentarnew = $save2['kommentar'] + 1;
    
  ## Neue Anzahl Kommentare in Blog Objekt speichern
  $save3 = $queryBuilder3 ->update('tx_ibkblog_domain_model_blog', 't')
    ->where(
      $queryBuilder3->expr()->eq('uid', $queryBuilder3->createNamedParameter($queryBlog, \PDO::PARAM_INT))
    )
    ->set('t.kommentar', $kommentarnew)
    ->execute();
  
  return $message;
}