DBIx::Class - получить все отношения, которые использовались в качестве условия, с помощью предварительной выборки?

Если у вас есть правильные отношения в вашей схеме, это возможно с помощью одного запроса. Но это сложно. Предположим, что ваша база данных выглядит так:

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' } } }

И, наконец, чтобы получить Models для этого отношения N:M, мы должны использовать магазин отношений model_id со стрелкой 4.

{
    '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 каждого Model (4) в наш список моделей для этого продукта. После этого только печать.

Вот еще один способ взглянуть на это:

Мы могли бы исключить последний model_id из prefetch, но тогда нам пришлось бы использовать get_column('model_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 действительно помогает нам, потому что все странные объединения и объединения полностью абстрагируются, и нам нужен только один единственный запрос, чтобы получить все данные.