Wie optimieren wir Laravel-Datenbankabfragen?

Wenn Ihre Anwendung langsam ausgeführt wird oder eine große Anzahl von Datenbankabfragen ausgeführt wird, befolgen Sie die folgenden Tipps zur Leistungsoptimierung, um die Ladezeit Der Anwendung zu verbessern.

1. Importieren großer Datensätze

Dieser Tipp konzentriert sich hauptsächlich auf die Verbesserung der Speichernutzung Ihrer Anwendung beim Umgang mit großen Datasets.

Wenn Ihre Anwendung ein großes Dataset verarbeiten muss, können Sie eine Teilmenge der Ergebnisse importieren und in Gruppen verarbeiten, anstatt es auf einmal zu importieren.

So rufen Sie einen großen Satz von Ergebnissen aus einer Tabelle ab Beiträge, machen wir in der Regel die folgenden.

$posts = Post::all(); 
$posts = DB::table('posts')->get();
foreach ($posts as $post) {
// Process posts
}

In den obigen Beispielen werden alle Datensätze in der Posttabelle importiert und verarbeitet. Was ist, wenn es 1 Million Zeilen in dieser Tabelle gibt? Sie werden leicht aus Ram laufen.

Um Probleme beim Umgang mit einem großen Dataset zuvermeiden,können Sie eine Teilmenge der Ergebnisse importieren und wie folgt verarbeiten.

// when using eloquent
$posts = Post::chunk(100, function($posts){
foreach ($posts as $post){
// Process posts
}
});
// when using query builder
$posts = DB::table('posts')->chunk(100, function ($posts){
foreach ($posts as $post){
// Process posts
}
});

Im obigen Beispiel werden 100 weitere Datensätze aus der Posttabelle abgerufen, verarbeitet, abgerufen und verarbeitet. Dieser Zyklus wird fortgesetzt, bis alle Datensätze verarbeitet werden.

Dieser Ansatz macht mehr Datenbankabfragen, macht den Speicher jedoch sehr effizient. In der Regel werden große Datasets im Hintergrund verarbeitet. Daher ist es in Ordnung, bei der Ausführung im Hintergrund mehr Abfragen zu tätigen, um zu verhindern, dass beim Verarbeiten großer Datasets nicht mehr Arbeitsspeicher zur Verfügung steht.

// when using eloquent
foreach (Post::cursor() as $post){
// Process a single post
}
// when using query builder
foreach (DB::table('posts')->cursor() as $post){
// Process a single post
}

Im obigen Beispiel wird eine einzelne Datenbank abgefragt, alle Datensätze aus der Tabelle importiert und aussagekräftige Modelle einzeln verarbeitet. Dieser Ansatz führt nur eine Datenbankabfrage aus, um alle Sendungen zu empfangen. Es verwendet jedoch PHP-Generatoren, um die Speichernutzung zu optimieren.

Wann können Sie diese

Obwohl dies die Speichernutzung auf Anwendungsebene erheblich optimiert, ist die Speicherauslastung in der Datenbankinstanz immer noch höher, da wir alle Eingaben in einer Tabelle empfangen.

Cursor ist besser zu verwenden, wenn Ihre Webanwendung, die Ihre Anwendung ausführt, über weniger Arbeitsspeicher und die Datenbankinstanz über mehr Arbeitsspeicher verfügt. Wenn Ihre Datenbankinstanz jedoch nicht über genügend Arbeitsspeicher verfügt, ist es besser, Chunk zu verwenden.

Hinweis: Diese Funktion ist nur auf laravel 8 und höher verfügbar.

// when using eloquent
$posts = Post::chunkById(100, function($posts){
foreach ($posts as $post){
// Process posts
}
});
// when using query builder
$posts = DB::table('posts')->chunkById(100, function ($posts){
foreach ($posts as $post){
// Process posts
}
});

StückUnd chunkById Der große Unterschied zwischen ihnen Idfeldbasierte Datenbankergebnisse. Dieses ID-Feld ist in der Regel ein Ganzzahlfeld, und in den meisten Fällen wird es automatisch ein inkrementiertes Feld sein.

Hergestellt durch Abfragen StückUnd chunkByIdwie folgt.

Stück

Wählen * aus Pfosten Offset 0 Limit 100

Wählen * aus Beiträgen Offset 101 Limit 100

chunkById

Wählen Sie * aus Posts-Auftrag nach id asc Limit 100

Wählen Sie * aus Beiträgen aus, bei denen id > 100 Order by id asc limit 100

In der Regel sind das Limit und der Offset langsamer und versuchen, die Verwendung zu vermeiden. Da ChunkById ein id-Feld verwendet, das ein Ganzzahlfeld ist, und eine Abfrage verwendet wo KlauselDie Abfrage ist viel schneller.

Wann können Sie chunkById verwenden? — Wenn Ihre Anwendung laravel 8 oder höher ausführt – in der Datenbanktabelle IdSie können es verwenden, wenn eine Spalte mit einem Ganzzahlfeld vorhanden ist.

2. Wählen Sie nur die Spalten, die Sie benötigen

In der Regel führen wir die folgenden Schritte aus, um Ergebnisse aus einer Datenbanktabelle zu erhalten.

$posts = Post::find(1); 
$posts = DB::table('posts')->where('id','=',1)->first();

Der obige Code führt zu einer Abfrage wie folgt.

Wählen Sie * aus Beiträgen aus, bei denen id = 1 Limit 1

Wie Sie sehen können, ist die Abfrage ein Wählen Sie *. Dies bedeutet, dass alle Spalten aus der Datenbanktabelle empfangen wurden. Wenn wir wirklich alle Spalten in der Tabelle brauchen, ist das in Ordnung.

Aber stattdessen, wenn wir nur bestimmte Spalten (id, Titel) brauchen, können wir nur diese Spalten erhalten, wie unten.

$posts = Post::select(['id','title'])->find(1); $posts = DB::table('posts')->where('id','=',1)->select(['id','title'])->first();

Der obige Code führt zu einer Abfrage wie folgt.

Wählen Sie id,title aus Beiträgen, bei denen id = 1 Limit 1

3. Verwenden Sie Zupfen, wenn Sie genau eine oder zwei Spalten aus der Datenbank benötigen

Dieser Tipp konzentriert sich mehr auf die Zeit, die nach dem Abrufen der Ergebnisse aus der Datenbank verbracht wurde. Dies wirkt sich nicht auf die tatsächliche Abfragedauer aus.

$posts = Post::select(['title','slug'])->get(); $posts = DB::table('posts')->select(['title','slug'])->get();

Wenn der obige Code ausgeführt wird, führt er im Hintergrund die folgenden Schritte aus.

  • Wählen Sie Titel, Schnecke von BeiträgenFührt eine Abfrage in einer Datenbank aus
  • Erhalten Bereitstellenerstellt ein neues Modellobjekt für jede Zeile (Erstellt ein PHP-Standardobjekt für den Abfragegenerator)
  • BereitstellenErstellt eine neue Kollektion mit Modellen
  • Gibt die Auflistung zurück

Lassen Sie uns nun die Ergebnisse erhalten.

foreach ($posts as $post){
$post->title;
$post->slug;
}

Der obige Ansatz ist Bereitstellenhat den Aufwand für die Modellierung für jede Zeile und das Erstellen einer Auflistung für diese Objekte. BereitstellenDies ist am besten, wenn Sie das Modell wirklich brauchen. Aber wenn Sie nur diese beiden Werte benötigen, können Sie die folgenden Schritte ausführen.

$posts = Post::p Glück ('Titel', 'Slug'); $posts = DB::table('posts')->pluck('title','slug');

Wenn der obige Code ausgeführt wird, führt er im Hintergrund die folgenden Schritte aus.

  • Wählen Sie Titel, Schnecke von BeiträgenFührt die Abfrage in der Datenbank aus.
  • Erstellt ein Array Arrayschlüssel.

Jetzt würden wir es tun, um die Ergebnisse zu erhalten.

für jeden ($posts wie $slug => $title)"
$title
$slug
}

Wenn Sie nur eine Spalte importieren möchten, können Sie:

$posts = Post::pluck('title'); $posts = DB::table('posts')->pluck('title'); foreach ($posts as $title){
$title
}

Der obige Ansatz Bereitstelleneliminiert die Erstellung von Objekten für jede Zeile. Dies reduziert die Speicherauslastung und den Zeitaufwand für die Verarbeitung von Abfrageergebnissen.

4. Zeilen mit Abfrage statt Auflistung zählen

Um die Gesamtzahl der Zeilen in einer Tabelle zu zählen, können Sie

$posts = Post::all()->count(); $posts = DB::table('posts')->get()->count();

Dadurch wird die folgende Abfrage generiert

Wählen * aus Beiträgen

Der obige Ansatz nimmt alle Zeilen aus der Tabelle, so dass sie Auflistungund zählen Sie die Ergebnisse. Dies funktioniert gut, wenn weniger Zeilen in der Datenbanktabelle vorhanden sind. Aber wenn das Bild wächst, wird unser Gedächtnis schnell aufgehen.

Anstelle des oben genannten Ansatzes können wir direkt die Gesamtzahl der Zeilen in der Datenbank selbst zählen.

$posts = Post::count(); $posts = DB::table('posts')->count();

Dadurch wird die folgende Abfrage generiert

Count(*) aus Beiträgen auswählen

Das Zählen von Zeilen in SQL ist ein langsamer Prozess und funktioniert sehr schlecht, wenn zu viele Zeilen in der Datenbanktabelle vorhanden sind. Es ist besser, Zeilen so weit wie möglich zu zählen.

5. Vermeiden Sie N+1-Abfragen mit willigen Installationsbeziehungen

Vielleicht haben Sie diesen Hinweis millionenfach gehört. Also werde ich es so kurz und einfach wie möglich halten. Angenommen, Sie haben das folgende Szenario

class PostController extends Controller
{
public function index()
{
$posts = Post::all();
return view('posts.index', ['posts' => $posts ]);
}
}
// posts/index.blade.php file@foreach($posts as $post)

  • {{ $post->title }}


    Author: {{ $post->author->name }}



  • @endforeach

    Der obige Code ist, alle Beiträge zu erhalten und den Titel und Autor des Artikels auf der Webseite anzuzeigen. Der obige Code Autorgeht davon aus, dass Sie eine Beziehung zu Ihrem Postmodell haben.

    Das Ausführen des obigen Codes führt dazu, dass die folgenden Abfragen ausgeführt werden.

    * aus Beiträgen auswählen / Angenommen, diese Abfrage hat 5 Beiträge zurückgegeben
    Wählen Sie * aus Autoren aus, bei denen die ID = post1.author_id
    Wählen Sie * aus Autoren aus, bei denen die ID = post2.author_id
    Wählen Sie * aus Autoren aus, bei denen die ID = post3.author_id
    Wählen Sie * aus Autoren aus, bei denen die ID = post4.author_id
    Wählen Sie * aus Autoren aus, bei denen die ID = post5.author_id

    Wie Sie sehen können, haben wir eine Abfrage, um die Beiträge und 5 Abfragen zu erhalten, um die Autoren der Beiträge zu erhalten (vorausgesetzt, wir haben 5 Einreichungen) Also für jeden Beitrag, den es erhält, macht es eine separate Abfrage, um seinen Autor zu erhalten.

    Wenn es also N-Anzahl von Beiträgen gibt, macht N+ 1 Abfrage (1 Abfrage, um die Beiträge zu erhalten, und N-Abfrage, um den Autor für jeden Beitrag abzubekommen). Dies wird allgemein als N+1-Abfrageproblem bezeichnet.

    Um dies zu vermeiden, laden Sie die Beziehung des Autors bereitwillig wie folgt in Publikationen hoch.

    $posts = Post::with(['author'])->get(); 

    Das Ausführen des obigen Codes führt dazu, dass die folgenden Abfragen ausgeführt werden.

    * aus Beiträgen auswählen / Angenommen, diese Abfrage hat 5 Beiträge zurückgegeben
    Wählen Sie * von Autoren aus, bei denen die ID in(post1.author_id , post2.author_id , post3.author_id , post4.author_id , post5.author_id )

    6. Willige Last verschachtelte Beziehung

    Beachten Sie im obigen Beispiel, dass der Autor zu einem Team gehört und Sie auch den Teamnamen anzeigen möchten. In der Blade-Datei tun Sie also wie folgt.

    @foreach($posts as $post)

  • {{ $post->title }}


    Author: {{ $post->author->name }}


    Author's Team: {{ $post->author->team->name }}



  • @endforeach

    Jetzt machen wir es so auf dem Controller.

    $posts = Post::with(['author'])->get();

    Dies führt zu den folgenden Abfragen.

    * aus Beiträgen auswählen / Angenommen, diese Abfrage hat 5 Beiträge zurückgegeben
    Wählen Sie * von Autoren aus, bei denen die ID in(post1.author_id , post2.author_id , post3.author_id , post4.author_id , post5.author_id )
    Wählen Sie * aus Teams aus, in denen die ID = author1.team_id
    Wählen Sie * aus Teams aus, in denen die ID = author2.team_id
    Wählen Sie * aus Teams aus, in denen die ID = author3.team_id
    Wählen Sie * aus Teams aus, in denen die ID = author4.team_id
    Wählen Sie * aus Teams aus, in denen die ID = author5.team_id

    Wie Sie sehen können AutorenWährend wir bereit sind, die Beziehung hochzuladen, stellt er immer noch weitere Anfragen. Weil Teamwir sind nicht bereit, die Beziehung hochzuladen.

    Wir können dies beheben, indem wir Folgendes tun.

    $posts = Post::with(['author.team'])->get();

    Das Ausführen des obigen Codes führt dazu, dass die folgenden Abfragen ausgeführt werden.

    * aus Beiträgen auswählen / Angenommen, diese Abfrage hat 5 Beiträge zurückgegeben
    Wählen Sie * von Autoren aus, bei denen die ID in(post1.author_id , post2.author_id , post3.author_id , post4.author_id , post5.author_id )
    Wählen Sie * aus Teams aus, in denen die ID in (in) , author1.team_id , author2.team_id , , author3.team_id , , author4.team_id , author5.team_id )

    Durch laden die verschachtelte Beziehung haben wir daher die Gesamtzahl der Abfragen von 11 auf 3 reduziert.

    7. Installieren Sie die OwnTo-Beziehung nicht, installieren Sie sie einfach, wenn Sie id benötigen

    Angenommen, Sie haben zwei Tabellen BeiträgeUnd Autoren. In der Schreibtabelle author_idDie Tabelle authors enthält eine Spalte, die eine OwnTo-Beziehung darstellt.

    Um die Autoren-ID eines Beitrags zu erhalten, würden wir normalerweise wie folgt vorgehen:

    $post = Post::findOrFail();  $post->autor->id;

    Dadurch werden zwei Abfragen ausgeführt.

    Wählen Sie * aus Beiträgen aus, bei denen id =  Grenzwert 1
    Wählen Sie * von Autoren aus, bei denen id = Limit 1

    Stattdessen können Sie die Autoren-ID direkt abrufen, indem Sie die folgenden Schritte ausführen.

    $post = Post::findOrFail();  $post->author_id;

    Wann kann ich den oben genannten Ansatz verwenden?

    Sie können den obigen Ansatz verwenden, wenn Sie sicher sind, dass in der Tabelle "Autoren" immer eine Zeile vorhanden ist.

    8. Vermeiden Sie unnötige Abfragen

    Meistens stellen wir Datenbankabfragen vor, die nicht erforderlich sind. Wie im folgenden Beispiel.

    class PostController extends Controller
    {
    public function index()
    {
    $posts = Post::all();
    $private_posts = PrivatePost::all();
    return view('posts.index', ['posts' => $posts, 'private_posts' => $private_posts ]);
    }
    }

    Der obige Code ruft Zeilen aus zwei verschiedenen Tabellen ab. Beiträgeprivate_posts) und passieren, um sie anzuzeigen. Die View-Datei sieht wie folgt aus.

    // posts/index.blade.php@if( request()->user()->isAdmin() )

    Private Posts



      @foreach($private_posts as $post)

    • {{ $post->title }}


      Published At: {{ $post->published_at }}



    • @endforeach

    @endif

    Posts



      @foreach($posts as $post)

    • {{ $post->title }}


      Published At: {{ $post->published_at }}



    • @endforeach

    Wie Sie oben sehen können, $private_postsNur Admin nicht alle Benutzer können diese Beiträge sehen.

    $posts = Post::all();
    $private_posts = PrivatePost::all();

    Wir machen zwei Verhöre. Jemand zeichnet auf Beiträgeaus der Tabelle, die anderen Datensätze private_posts, um aus der Tabelle abzurufen .

    private_postsDatensätze in einer Tabelle können nur Admin-Benutzer. Wir fragen jedoch ab, um diese Datensätze für alle Benutzer abzubekommen.

    Um diese zusätzliche Abfrage zu vermeiden, können Sie wie folgt vorgehen.

    $posts = Post::all();$private_posts = collect();if( request()->user()->isAdmin() ){
    $private_posts = PrivatePost::all();
    }

    Indem wir unsere Logik wie oben ändern, stellen wir zwei Abfragen für den administrativen Benutzer und eine Abfrage für alle anderen Benutzer.

    9. Kombinieren sie ähnlicher Abfragen

    Manchmal müssen wir Abfragen durchführen, um verschiedene Zeilentypen aus derselben Tabelle abzurufen.

    $published_posts = Post::where('status',=','published')->get();
    $featured_posts = Post::where('status',=','featured')->get();
    $scheduled_posts = Post::where('status','=','scheduled')->get();

    Der obige Code nimmt Zeilen an, die sich von derselben Tabelle unterscheiden. Der Code führt dazu, dass die folgenden Abfragen ausgeführt werden.

    Wählen Sie * aus Beiträgen aus, bei denen Status = 'veröffentlicht' ist
    Wählen Sie * aus Beiträgen aus, bei denen Status = 'featured'
    Wählen Sie * aus Beiträgen aus, bei denen Status = 'geplant'

    Wie Sie sehen können, macht er drei verschiedene Abfragen an dieselbe Tabelle, um die Datensätze zurückzubekommen. Wir können diesen Code so anordnen, dass nur eine Datenbankabfrage erstellt wird.

    $posts = Post::whereIn('status',['published', 'featured', 'scheduled'])->get();$published_posts = $posts->where('status','=','published');
    $featured_posts = $posts->where('status','=','featured');
    $scheduled_posts = $posts->where('status','=','scheduled');
    Wählen Sie * aus Beiträgen aus, in denen der Status in ( 'veröffentlicht', 'featured', 'scheduled' )

    Der obige Code besteht darin, eine einzelne Abfrage zu erstellen, um alle Sendungen mit einem der angegebenen Status zu empfangen und separate Sammlungen für jeden Status zu erstellen, indem die zurückgegebenen Sendungen nach ihrem Status gefiltert werden. Daher haben wir mit ihrem Status immer noch drei verschiedene Variablen und wir machen nur eine Abfrage.

    10. Verwenden Sie simplePaginate statt paginieren

    Normalerweise verwenden wir beim Patenieren der Ergebnisse die folgende Methode.

    $posts = Post::p aginate(20);

    Dies wird zwei Verhöre bewirken. 1, um paginierte Ergebnisse zu erhalten, und die andere, um die Gesamtzahl der Zeilen in der Tabelle zu zählen. Das Zählen von Zeilen in einer Tabelle ist ein langsamer Prozess und wirkt sich negativ auf die Abfrageleistung aus.

    Warum zählt laravel also die Gesamtzahl der Zeilen?

    Um Paginierungsverknüpfungen zu erstellen, zählt Laravel die Gesamtzahl der Zeilen. Wenn paginierungslinks erstellt werden, wissen Sie daher im Voraus, wie viele Seiten vorhanden sein werden und wie hoch die vergangene Seitenzahl ist. So können Sie ganz einfach zu jeder Seite gehen, die Sie wollen.

    Auf der anderen Seite simplePaginatezählt nicht die Gesamtzahl der Zeilen und die Abfrage Paginatewird viel schneller sein als der Ansatz. Sie verlieren jedoch die Möglichkeit, die letzte Seitenzahl zu kennen und zu verschiedenen Seiten zu wechseln.

    Wenn Ihre Datenbanktabelle eine große Anzahl von Zeilen enthält, PaginateStatt simplePaginate es ist besser, es zu tun.

    $posts = Post::p aginate(20); $posts = Post::simplePaginate(20);

    11. Vermeiden Sie die Verwendung führender Platzhalter (LIKE-Schlüsselwort)

    Wenn Sie versuchen, Ergebnisse abzufragen, die einem bestimmten Modell entsprechen,

    Wählen Sie * aus table_name aus, in denen Spalte wie %keyword%

    Die obige Abfrage führt zu einem vollständigen Tabellenscan. Wenn wir wissen, dass sich das Schlüsselwort am Anfang des Spaltenwerts befindet, können wir die Ergebnisse wie folgt in Frage stellen.

    Wählen Sie * aus table_name wo Spalte wie Schlüsselwort%

    12. Vermeiden Sie die Verwendung von SQL-Funktionen in

    Es ist immer besser, SQL-Funktionen in dem Punkt zu vermeiden, da es immer zu einem vollständigen Tabellenscan führt. Sehen wir uns das Beispiel unten an. Um Ergebnisse nach einem bestimmten Datum abzufragen,

    $posts = POST::whereDate('created_at', '>=', now() )->get();

    Dies führt zu einer Abfrage, die der folgenden ähnelt

    Wählen Sie * aus Beiträgen aus, bei denen Datum(created_at) >= 'timestamp-here'

    Die obige Abfrage DatumEs führt zu einem vollständigen Tabellenscan, da die Where-Bedingung erst angewendet wird, wenn die Funktion ausgewertet wird.

    DatumWir können dies wie folgt neu anordnen, um sql-Funktionalität zu vermeiden

    $posts = Post::where('created_at', '>=', now() )->get(); Wählen Sie * aus Beiträgen aus, in denen created_at >= 'timestamp-here'

    13. Vermeiden Sie das Hinzufügen zu vieler Spalten zu einer Tabelle

    Es ist besser, die Gesamtzahl der Spalten in einer Tabelle zu begrenzen. Relationale Datenbanken, z. B. Mysql, können verwendet werden, um mehrspaltige Tabellen in mehrere Tabellen aufzuteilen. Sie können mit ihren Primär- und Fremdschlüsseln kombiniert werden.

    Durch das Hinzufügen zu vieler Spalten zu einer Tabelle wird die Länge des einzelnen Datensatzes erhöht und das Scannen von Tabellen verlangsamt. Eins Wählen Sie *Wenn Sie abfragen, erhalten Sie eine Gruppenspalte, die Sie nicht wirklich benötigen.

    14. Besserer Weg, um die neuesten Zeilen aus einer Tabelle abzurufen

    Wenn wir die neuesten Zeilen aus einer Tabelle abrufen möchten,

    $posts = Post::latest()->get();
    oder $posts = Post::orderBy('created_at', 'desc')->get();

    Der obige Ansatz führt zu der folgenden SQL-Abfrage.

    Wählen Sie * aus Derpost-Auftrag von created_at desc

    Die Abfrage sortiert Zeilen im Grunde nach created_at Spalte in absteigender Reihenfolge. Da es sich bei der created_at Spalte um eine Zeichenfolgenspalte handelt, ist das Sortieren der Ergebnisse auf diese Weise in der Regel langsamer.

    Wenn Ihre Datenbanktabelle über eine Primärschlüssel-ID verfügt, die automatisch ansteigt, hat die letzte Zeile in den meisten Fällen immer die höchste ID. Da es sich bei dem ID-Feld um ein ganzzahliges Feld und auch um einen Primärschlüssel handelt, ist es viel schneller, die Ergebnisse nach diesem Schlüssel zu sortieren. Daher ist der bessere Weg, um die neuesten Zeilen zu erhalten, wie folgt.

    $posts = Post::latest('id')->get();
    oder $posts = Post::orderBy('id', 'desc')->get();
    Wählen Sie * aus Posts-Auftrag von id desc

    15. Abfragen überprüfen und optimieren

    Es gibt keine einzige universelle Lösung bei der Optimierung von Abfragen in Laravel. Nur Sie wissen, was Ihre App macht, wie viele Abfragen sie macht, wie viele tatsächlich verwendet werden. Daher können Sie durch das Untersuchen von Abfragen, die von Ihrer Anwendung durchgeführt werden, die Gesamtzahl der abfragen ermitteln und reduzieren.

    Mit dem folgenden Tool können Sie Abfragen auf jeder Seite überprüfen.

    • Laravel Debugbar — Laravel Debugbar, eine SeiteDatenbankhat eine Registerkarte, die alle Abfragen anzeigt, die beim Besuch ausgeführt werden. Besuchen Sie alle Seiten in Ihrer App, und sehen Sie sich die Abfragen an, die auf jeder Seite ausgeführt werden.

      Zitat

    KARABAY A, 2021 . Wie optimieren wir Laravel Database Queries?

    https://www.karabayyazilim.com/blog/php/framework/laravel/laravel-veritabani-sorgularini-nasil-optimize-ederiz-2021-03-21-185044

    (Zugriff am 21. März 2021).


      Diesen Beitrag teilen

    Kommentare (1)

    • berat Antwort

      Lehrer, du hast es gut verschüttet. Wir warten auf mehr. :)

      vor 3 Monaten

      Kommentar

      Abonnieren
      Melden Sie sich für den E-Mail-Newsletter an, um als Erster über meine Blogbeiträge Bescheid zu wissen