Question

以下是三个表格：product，model和product_model，用N：M关系映射产品和模型。

product          product_model            model

id name          product_id model_id      id name
------------     -------------------      ----------
p1 Product 1     p1         m1            m1 Model 1
p2 Product 2     p2         m1            m2 Model 2
...              p2         m2

我想做什么：查找支持模型2的所有产品（例如product 2）。然后，对于每个产品，显示产品支持的model_ids列表（product 2 =＆gt; [m1，m2]）

这是我的第一次尝试。我需要N个查询来搜索每个产品的model_id。

# 1 query for searching products
my @products = $schema->resultset('Product')->search(
   { 'product_models.model_id' => 'm2' },
   { 'join' => 'product_model' },
)
# N queries for searching product_models for each product
foreach my $product ( @products ) {
   my @model_ids = map { $_->model_id } $product->product_models;
   # @model_ids = ( 'm1', 'm2' ) for p2
}

我找了一种方法来只使用一个查询来获得结果。用join替换prefetch无效。

my @products = $schema->resultset('Product')->search(
   { 'product_models.model_id' => 'm2' },
   { 'prefetch' => 'product_model' },      # here
)

# no additional queries, but...
foreach my $product ( @products ) {
   my @model_ids = map { $_->model_id } $product->product_models;
   # now, @model_ids contains only ( `m2` )
}

接下来，我尝试了“预取同一张桌子两次”：

my @products = $schema->resultset('Product')->search(
    { 'product_models.model_id' => 'm2' },
    { 'prefetch' => [ 'product_models', 'product_models' ] },
);

foreach my $product ( @products ) {
    my @model_ids = map { $_->model_id } $product->product_models;
}

我似乎成功了。只执行了一个查询，我从中获得了所有模型ID。

但是我不太确定这是正确的（？）方式。这是正确的做法吗？

例如，如果我使用join代替prefetch，则Product 2会在循环中出现两次。我理解，因为连接表就像：

id name      p_m.p_id p_m.m_id p_m_2.p_id p_m_2.m_id
p2 Product 2 p2       m2       p2         m1
p2 Product 2 p2       m2       p2         m2   -- Product 2, one more time

为什么Product 2只在我使用prefetch时出现一次？

结果查询几乎相同，但SELECT字段的差异除外：

SELECT "me"."id", "me"."name",
 "product_models"."product_id", "product_models"."model_id",    -- only in prefetch
 "product_models_2"."product_id", "product_models_2"."model_id" --
  FROM "product" "me"
  LEFT JOIN "product_model" "product_models"
    ON "product_models"."product_id" = "me"."id"
  LEFT JOIN "product_model" "product_models_2"
    ON "product_models_2"."product_id" = "me"."id"
WHERE "product_models"."model_id" = 'm2'

Answer 1

如果您的架构中有正确的关系，则可以使用单个查询。但这很棘手。我们假设您的数据库如下所示：

CREATE TABLE product
 (`id` VARCHAR(2) PRIMARY KEY, `name` VARCHAR(9))
;
INSERT INTO product
 (`id`, `name`) VALUES
 ('p1', 'Product 1'),
 ('p2', 'Product 2')
;
CREATE TABLE product_model (
  `product_id` VARCHAR(2),
  `model_id` VARCHAR(2),
  PRIMARY KEY (product_id, model_id),
  FOREIGN KEY(product_id) REFERENCES product(id),
  FOREIGN KEY(model_id) REFERENCES model(id)
)
;
INSERT INTO product_model
 (`product_id`, `model_id`) VALUES
 ('p1', 'm1'),
 ('p2', 'm1'),
 ('p2', 'm2')
;
CREATE TABLE model
 (`id` VARCHAR(2) PRIMARY KEY, `name` VARCHAR(7))
;
INSERT INTO model
 (`id`, `name`) VALUES
 ('m1', 'Model 1'),
 ('m2', 'Model 2')
;

这基本上是你的问题数据库。我添加了主键和外键。无论如何你可能还有那些。

我们现在可以从中创建一个模式。我编写了一个使用DBIx::Class::Schema::Loader来执行此操作的简单程序。它可以动态创建SQLite数据库。（如果没有人把它放在CPAN上，我会的。）

上面的SQL将放在__DATA__部分。

use strict;
use warnings;
use DBIx::Class::Schema::Loader qw/ make_schema_at /;

# create db
unlink 'foo.db';
open my $fh, '|-', 'sqlite3 foo.db' or die $!;
print $fh do { local $/; <DATA> };
close $fh;

$ENV{SCHEMA_LOADER_BACKCOMPAT} = 1;

# create schema
my $dsn = 'dbi:SQLite:foo.db';
make_schema_at(
    'DB',
    {
        #    debug => 1,
    },
    [ $dsn, 'sqlite', '', ],
);

$ENV{DBIC_TRACE} = 1;

# connect schema
my $schema = DB->connect($dsn);

# query goes here

__DATA__
# SQL from above

现在我们有了这个，我们可以专注于查询。起初这看起来很可怕，但我会尝试解释。

my $rs     = $schema->resultset('Product')->search(
    { 'product_models.model_id' => 'm2' },
    {
        'prefetch' => {
            product_models => {
                product_id => {
                    product_models => 'model_id'
                }
            }
        }
    },
);

while ( my $product = $rs->next ) {
    foreach my $product_model ( $product->product_models->all ) {
        my @models;
        foreach my $supported_model ( $product_model->product_id->product_models->all ) {
            push @models, $supported_model->model_id->id;
        }
        printf "%s: %s\n", $product->id, join ', ', @models;
    }
}

prefetch表示加入此关系，并保留数据以供日后使用。因此，要获得产品的所有型号，我们必须编写

#          1                   2
{ prefetch => { product_models => 'product_id' } }

其中product_models是N：M表，product_id是与Models表关系的名称。箭头=> 1 用于从Product到ProductModel的第一次加入。 2 用于ProductModel返回每个具有 m2 模型的产品。有关说明，请参阅ER模型的图纸。

现在我们希望拥有此ProductModel所拥有的所有Product个。那个箭头 3 。

#          1                   2               3
{ prefetch => { product_models => { product_id => 'product_models' } } }

最后，要获得N {M关系的Model s，我们必须使用带有箭头 4 的model_id关系商店。

{
    'prefetch' => {                            # 1
        product_models => {                    # 2
            product_id => {                    # 3
                product_models => 'model_id'   # 4
            }
        }
    }
},

查看ER模型图应该清楚。请记住，默认情况下，每个连接都是LEFT OUTER连接，因此它始终会获取所有行，而不会丢失任何内容。 DBIC正在为您解决这个问题。

现在要访问所有这些，我们需要迭代。 DBIC为我们提供了一些工具。

while ( my $product = $rs->next ) {

    #                                   1
    foreach my $product_model ( $product->product_models->all ) {
        my @models;

        #                                           2           3
        foreach my $supported_model ( $product_model->product_id->product_models->all ) {

            #                             4 
            push @models, $supported_model->model_id->id;
        }
        printf "%s: %s\n", $product->id, join ', ', @models;
    }
}

首先，我们抓住所有ProductModel条目（ 1 ）。对于其中每个，我们采用Product（ 2 ）。每行中始终只有一个Product，因为这样我们就有1：N的关系，所以我们可以直接访问它。此Product反过来具有ProductModel关系。那是 3 。因为这是N方面，我们需要采取所有这些并进行迭代。然后，我们将每个id {<1>}（ 4 ）的Model推送到此产品的模型列表中。在那之后，它只是打印。

以下是另一种观察方式：

我们可以消除model_id中的最后prefetch，但我们必须使用get_column('model_id')来获取ID。它会为我们节省一次加入。

现在，如果我们打开DBIC_TRACE=1，我们会得到这个SQL语句：

SELECT me.id, me.name, product_models.product_id, product_models.model_id, product_id.id, product_id.name, product_models_2.product_id, product_models_2.model_id, model_id.id, model_id.name
FROM product me
LEFT JOIN product_model product_models ON product_models.product_id = me.id
LEFT JOIN product product_id ON product_id.id = product_models.product_id
LEFT JOIN product_model product_models_2 ON product_models_2.product_id = product_id.id
LEFT JOIN model model_id ON model_id.id = product_models_2.model_id
WHERE (product_models.model_id = 'm2')
ORDER BY me.id

如果我们针对我们的数据库运行此操作，我们会有以下行：

p2|Product 2|p2|m2|p2|Product 2|p2|m1|m1|Model 1
p2|Product 2|p2|m2|p2|Product 2|p2|m2|m2|Model 2

当然，如果我们手动完成它会毫无用处，但DBIC的魔法确实对我们有所帮助，因为所有奇怪的加入和组合都被完全抽象化了，我们只需要一个查询来获取所有数据。

DBIx :: Class - 使用prefetch获取用作条件的所有关系？

1 个答案: