So verwenden Sie Join und Join mit Abfragen für mehrere Tabellen in Yii2

In diesem Artikel wird hauptsächlich die Verwendung von Multi-Table-Assoziationsabfragen (Join, Joinwith) in Yii2 vorgestellt. Ich hoffe, es hilft allen.

Tabellenstruktur

Jetzt gibt es Kundentabelle, Bestelltabelle, Büchertabelle, Autorentabelle,

Kundentabelle Kunde (ID Kundenname)
Bestelltabelle Bestellung (ID Bestellname Kunden-ID Buch-ID)
Buchtabelle (ID Buchname Autor_ID)
Autorentabelle (ID Autorname)

Modelldefinition

Im Folgenden sind die Definitionen dieser vier Modelle aufgeführt, nur die Beziehungen zwischen ihnen werden geschrieben

Kunde

class Customer extends \yii\db\ActiveRecord
{
// 这是获取客户的订单，由上面我们知道这个是一对多的关联，一个客户有多个订单
public function getOrders()
{
// 第一个参数为要关联的子表模型类名，
// 第二个参数指定 通过子表的customer_id，关联主表的id字段
return $this->hasMany(Order::className(), ['customer_id' => 'id']);
}
}

Bestellen

class Order extends \yii\db\ActiveRecord
{
// 获取订单所属用户
public function getCustomer()
{
//同样第一个参数指定关联的子表模型类名
//
return $this->hasOne(Customer::className(), ['id' => 'customer_id']);
}
// 获取订单中所有图书
public function getBooks()
{
//同样第一个参数指定关联的子表模型类名
//
return $this->hasMany(Book::className(), ['id' => 'book_id']);
}
}

Buchen

class Book extends \yii\db\ActiveRecord
{
// 获取图书的作者
public function getAuthor()
{
//同样第一个参数指定关联的子表模型类名
return $this->hasOne(Author::className(), ['id' => 'author_id']);
}
}

Autor

class Autor extends \yii\db\ActiveRecord
{
}

hasMany, hasOne use

Es gibt zwei Arten von Zuordnungen zwischen Tabellen in Yii2, die zur Angabe der Zuordnung zwischen zwei Modellen verwendet werden.

Eins-zu-viele: hasMany

Eins-zu-eins: hasOne

Rückgabeergebnisse: Die Rückgabeergebnisse dieser beiden Methoden sind yiidbActiveQuery Objekte

Der erste Parameter: der Klassenname des zugehörigen Modells.

Der zweite Parameter: ist ein Array, wobei die Schlüssel die Attribute im zugehörigen Modell und die Werte die Attribute im aktuellen Modell sind.

Zugehörige Nutzung

Jetzt erhalten wir alle Bestellinformationen eines Kunden

// 获取一个客户信息
$customer = Customer::findOne(1);
$orders = $customer->orders; // 通过在Customer中定义的关联方法（getOrders()）来获取这个客户的所有的订单。

Die beiden oben genannten Codezeilen generieren die folgende SQL-Anweisung

SELECT * FROM customer WHERE id=1;
SELECT * FROM order WHERE customer_id=1;

Assoziationsergebnis-Cache

Wenn sich die Bestellung des Kunden ändert, rufen wir erneut an

$orders = $customer->orders;

Wenn Sie die Bestellung erneut erhalten, werden Sie feststellen, dass es keine Änderung gibt. Der Grund dafür ist, dass die Datenbank nur abgefragt wird, wenn $customer->orders zum ersten Mal ausgeführt wird, die Ergebnisse zwischengespeichert werden und SQL bei nachfolgenden Abfragen nicht ausgeführt wird.

Was ist, wenn ich SQL erneut ausführen möchte? Sie können

unset($customer->orders);
$customer->orders;

ausführen und dann Daten aus der Datenbank abrufen.

Mehrere Assoziationen definieren

Ähnlich können wir auch mehrere Assoziationen in „Kunde“ definieren.
Wenn die Gesamtzahl der zurückgegebenen Bestellungen mehr als 100 beträgt.

class Customer extends \yii\db\ActiveRecord
{
public function getBigOrders($threshold = 100)
{
return $this->hasMany(Order::className(), ['customer_id' => 'id'])
->where('subtotal > :threshold', [':threshold' => $threshold])
->orderBy('id');
}
}

Zwei Zugriffsmethoden verknüpft

Wie oben, wenn Sie

< verwenden 🎜>

$customer->bigOrders

erhalten alle Bestellungen über 100. Wenn Sie Bestellungen mit mehr als 200 zurückgeben möchten, können Sie so schreiben:

$orders = $customer->getBigOrders(200)->all();

Wie Sie oben sehen können, gibt es zwei Möglichkeiten, auf eine Zuordnung zuzugreifen

Bei Aufruf als Funktion wird ein ActiveQuery-Objekt ($customer->getOrders()->all()) zurückgegeben.

Bei Aufruf als Attribut wird das Modell direkt zurückgegeben ($customer->orders)

Mit dem folgenden Code soll eine Kundenbestellung entgegengenommen werden

// 执行sql语句: SELECT * FROM customer WHERE id=1
$customer = Customer::findOne(1);
//执行sql：SELECT * FROM order WHERE customer_id=1
$orders1 = $customer->orders;
//这个不会执行sql，直接使用上面的缓存结果
$orders2 = $customer->orders;

Wenn wir jetzt 100 Benutzer herausnehmen und dann auf die Bestellungen jedes Benutzers zugreifen möchten, können wir aus dem obigen Verständnis den folgenden Code schreiben

// 执行sql语句: SELECT * FROM customer LIMIT 100
$customers = Customer::find()->limit(100)->all();
foreach ($customers as $customer) {
// 执行sql: SELECT * FROM order WHERE customer_id=...
$orders = $customer->orders;
// 处理订单。。。
}

Wenn wir es jedoch wirklich so schreiben wollen, wird SQL einmal in jeder Schleife von foreach ausgeführt, um Daten in der Datenbank abzufragen. Weil jedes $customer-Objekt anders ist.

Um das oben genannte Problem zu lösen, können Sie yiidbActiveQuery::with() verwenden.

Der Breitenparameter ist der Name der Beziehung, d. h. im Modell definierte getOrders, Bestellungen und Kunde in getCustomer

// 先执行sql: SELECT * FROM customer LIMIT 100;
// SELECT * FROM orders WHERE customer_id IN (1,2,...)
$customers = Customer::find()->limit(100)
->with('orders')->all();
foreach ($customers as $customer) {
// 在这个循环的时候就不会再执行sql了
$orders = $customer->orders;
// ...handle $orders...
}

Falls verwendet Wenn Sie „select“ verwenden, um die zurückgegebenen Spalten anzugeben, stellen Sie sicher, dass die zurückgegebenen Spalten die zugehörigen Felder des zugehörigen Modells enthalten, andernfalls ist das Modell

< der zugehörigen Tabelle nicht vorhanden zurückgegeben. 🎜>

$orders = Order::find()->select(['id', 'amount'])->with('customer')->all();
// $orders[0]->customer 的结果将会是null
// 因为上面的select中没有返回所关联的模型（customer）中的指定的关联字段。
// 如果加上customer_id，$orders[0]->customer就可以返回正确的结果
$orders = Order::find()->select(['id', 'amount', 'customer_id'])->with('customer')->all();

Filterbedingungen hinzufügen zu mitEine Bestellung mit mehr als 100 Kunden abfragen

Fragen Sie die Bestellungen von 100 Kunden ab. Die Gesamtsumme jedes Kunden ist größer als 100 Bestellungen.

//首先执行sql： SELECT * FROM customer WHERE id=1
$customer = Customer::findOne(1);
// 再执行查询订单的sql语句：SELECT * FROM order WHERE customer_id=1 AND subtotal>100
$orders = $customer->getOrders()->where('subtotal>100')->all();

Hier ist der Breitenparameter ein Array, der Schlüssel ist der zugehöriger Name und der Wert ist eine Rückruffunktion.

// 下面的代码会执行sql语句: 
// SELECT * FROM customer LIMIT 100
// SELECT * FROM order WHERE customer_id IN (1,2,...) AND subtotal>100
$customers = Customer::find()->limit(100)->with([
'orders' => function($query) {
$query->andWhere('subtotal>100');
},
])->all();

Das heißt, für die von der Auftragszuordnung zurückgegebene ActiveQuery führen Sie $query->andWhere('subtotal>100'); aus.

Verwenden Sie joinWith to Machen Sie die Tabellenassoziation Wir alle wissen, dass wir „Join on“ verwenden können, um Assoziationen zwischen mehreren Tabellen zu schreiben. Schauen Sie sich zunächst die Deklaration von joinWit in yii2 an

$with Der Datentyp ist eine Zeichenfolge oder ein Array. Wenn es sich um eine Zeichenfolge handelt, ist es der Name des Im Modell definierte Assoziation (kann eine Unterassoziation sein).

joinWith( $with, $eagerLoading = true, $joinType = 'LEFT JOIN' )

Wenn es sich um ein Array handelt, ist der Schlüssel die im getXXX-Format im Modell definierte Assoziation und der Wert die weitere Rückrufoperation für diese Assoziation.

$eagerLoading Ob die Daten des in $with verknüpften Modells geladen werden sollen.

$joinType 联接类型，可用值为：LEFT JOIN、INNER JOIN，默认值为LEFT JOIN

// 订单表和客户表以Left join的方式关联。
// 查找所有订单,并以客户 ID 和订单 ID 排序
$orders = Order::find()->joinWith('customer')->orderBy('customer.id, order.id')->all();
// 订单表和客户表以Inner join的方式关联
// 查找所有的订单和书
$orders = Order::find()->innerJoinWith('books')->all();
// 使用inner join 连接order中的 books关联和customer关联。
// 并对custmer关联再次进行回调过滤：找出24小时内注册客户包含书籍的订单
$orders = Order::find()->innerJoinWith([
'books',
'customer' => function ($query) {
$query->where('customer.created_at > ' . (time() - 24 * 3600));
}
])->all();
// 使用left join连接 books关联，books关联再用left join 连接 author关联
$orders = Order::find()->joinWith('books.author')->all();

在实现上，Yii 先执行满足JOIN查询条件的SQL语句，把结果填充到主模型中， 然后再为每个关联执行一条查询语句， 并填充相应的关联模型。

// Order和books关联 inner join ,但不获取books关联对应的数据
$orders = Order::find()->innerJoinWith('books', false)->all();

On条件

在定义关联的时候还可以指定on条件

class User extends ActiveRecord
{
public function getBooks()
{
return $this->hasMany(Item::className(), ['owner_id' => 'id'])->onCondition(['category_id' => 1]);
}
}

在joinWith中使用

//先查询主模型（User）的数据， SELECT user.* FROM user LEFT JOIN item ON item.owner_id=user.id AND category_id=1
// 然后再根据关联条件查询相关模型数据SELECT * FROM item WHERE owner_id IN (...) AND category_id=1
// 这两个在查询的过程中都使用了 on条件。
$users = User::find()->joinWith('books')->all();

如果没有使用join操作，即使用的是with 或者 直接以属性来访问关联。这个时候on条件会作为where 条件。

// SELECT * FROM user WHERE id=10
$user = User::findOne(10);

总结

首先需要在模型中定义好关联（如getOrders中的Orders为一个关联）

然后在with或者joinWith中使用在模型中定义的关联。

其中在使用关联的时候还可以指定回调方法。

再有就是可以给关联、with、joinWith指定where或者on条件。

相关推荐：

Yii2实现QQ互联登录

Yii2使用缓存的简单解析

Yii2实现rbac权限控制

Das obige ist der detaillierte Inhalt vonSo verwenden Sie Join und Join mit Abfragen für mehrere Tabellen in Yii2. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!