Estou trabalhando em um aplicativo em que um usuário pode ter acesso a muitos formulários através de vários cenários diferentes. Estou tentando criar a abordagem com o melhor desempenho ao retornar um índice de formulários para o usuário.

Um usuário pode ter acesso aos formulários através dos seguintes cenários:

• Possui Formulário
• Equipe possui Formulário
• Tem permissões para um grupo que possui um formulário
• Tem permissões para uma equipe que possui um formulário
• Tem permissão para um formulário

Como você pode ver, existem 5 maneiras possíveis de o usuário acessar um formulário. Meu problema é como retornar com mais eficiência uma matriz de formulários acessíveis ao usuário.

Política do formulário:

Tentei obter todos os formulários do modelo e filtrar os formulários pela política de formulários. Isso parece ser um problema de desempenho, pois em cada iteração de filtro o formulário é passado por um método eloqüente contains () 5 vezes, conforme mostrado abaixo. Quanto mais formulários no banco de dados, isso fica mais lento.

FormController@index

public function index(Request $request)
{
   $forms = Form::all()
      ->filter(function($form) use ($request) {
         return $request->user()->can('view',$form);
   });
}

FormPolicy@view

public function view(User $user, Form $form)
{
   return $user->forms->contains($form) ||
      $user->team->forms->contains($form) ||
      $user->permissible->groups->forms($contains);
}

Embora o método acima funcione, é um gargalo de desempenho.

Pelo que posso ver, minhas seguintes opções são:

• Filtro FormPolicy (abordagem atual)
• Consultar todas as permissões (5) e mesclar em coleção única
• Consulte todos os identificadores para obter todas as permissões (5) e, em seguida, consulte o modelo de formulário usando os identificadores em uma instrução IN ()

Minha pergunta:

Qual método forneceria o melhor desempenho e há outra opção que proporcionaria um melhor desempenho?

Eu gostaria de fazer uma consulta SQL, pois isso terá um desempenho muito melhor que o php

Algo assim:

User::where('id', $request->user()->id)
    ->join('group_users', 'user.id', 'group_users.user_id')
    ->join('team_users', 'user.id', 'team_users.user_id',)
    ->join('form_owners as user_form_owners', function ($join) {
        $join->on('users.id', 'form_owners.owner_id')
            ->where('form_owners.owner_type', User::class);
    })
    ->join('form_owners as group_form_owners', function ($join) {
        $join->on('group_users.group_id', 'form_owners.owner_id')
            ->where('form_owners.owner_type', Group::class);
    })
    ->join('form_owners as team_form_owners', function ($join) {
        $join->on('team_users.team_id', 'form_owners.owner_id')
           ->where('form_owners.owner_type', Team::class);
    })
    ->join('forms', function($join) {
        $join->on('forms.id', 'user_form_owners.form_id')
            ->orOn('forms.id', 'group_form_owners.form_id')
            ->orOn('forms.id', 'team_form_owners.form_id');
    })
    ->selectRaw('forms.*')
    ->get();

Do alto da minha cabeça e não testado, você deve obter todos os formulários que pertencem ao usuário, aos grupos dele e às equipes.

No entanto, ele não analisa as permissões dos formulários de exibição do usuário em grupos e equipes.

Não tenho certeza de como você configurou sua autenticação para isso e, portanto, seria necessário modificar a consulta para essa e qualquer diferença na sua estrutura de banco de dados.

Resposta curta

A terceira opção: Query all identifiers for all permissions (5), then query the Form model using the identifiers in an IN() statement

$teamMorphType  = Relation::getMorphedModel('team');
$groupMorphType = Relation::getMorphedModel('group');
$formMorphType  = Relation::getMorphedModel('form');

$permissible = [
    $teamMorphType  => [$user->team_id],
    $groupMorphType => [],
    $formMorphType  => [],
];

foreach ($user->permissible as $permissible) {
    switch ($permissible->permissible_type) {
        case $teamMorphType:
        case $groupMorphType:
        case $formMorphType:
            $permissible[$permissible->permissible_type][] = $permissible->permissible_id;
            break;
    }
}

$forms = Form::query()
             ->where('user_id', '=', $user->id)
             ->orWhereIn('id', $permissible[$fromMorphType])
             ->orWhereIn('team_id', $permissible[$teamMorphType])
             ->orWhereIn('group_id', $permissible[$groupMorphType])
             ->get();

Resposta longa

Por um lado, (quase) tudo o que você pode fazer no código é melhor em termos de desempenho do que nas consultas.

Por outro lado, obter mais dados do banco de dados do que o necessário já seria um excesso de dados (uso de RAM e assim por diante).

Na minha perspectiva, você precisa de algo intermediário, e só você saberá onde estaria o equilíbrio, dependendo dos números.

Sugiro executar várias consultas, a última opção que você propôs ( Query all identifiers for all permissions (5), then query the Form model using the identifiers in an IN() statement):

1. Consultar todos os identificadores, para todas as permissões (5 consultas)
2. Mesclar todos os resultados de formulários na memória e obter valores exclusivos array_unique($ids)
3. Consulte o modelo de formulário, usando os identificadores em uma instrução IN ().

Você pode tentar as três opções propostas e monitorar o desempenho, usando alguma ferramenta para executar a consulta várias vezes, mas tenho 99% de certeza de que a última fornecerá o melhor desempenho.

Isso também pode mudar bastante, dependendo de qual banco de dados você estiver usando, mas se estamos falando sobre MySQL, por exemplo; Em Uma consulta muito grande usaria mais recursos do banco de dados, que não apenas gastariam mais tempo do que consultas simples, mas também bloqueariam a tabela de gravações, e isso pode produzir erros de conflito (a menos que você use um servidor escravo).

Por outro lado, se o número de IDs de formulários for muito grande, você poderá ter erros para muitos espaços reservados, portanto, você pode agrupar as consultas em grupos de, digamos, 500 IDs (isso depende muito, pois o limite tem tamanho, não número de ligações) e mescla os resultados na memória. Mesmo se você não receber um erro no banco de dados, também poderá ver uma grande diferença no desempenho (ainda estou falando do MySQL).

Implementação

Vou assumir que este é o esquema do banco de dados:

users
  - id
  - team_id

forms
  - id
  - user_id
  - team_id
  - group_id

permissible
  - user_id
  - permissible_id
  - permissible_type

Tão admissível seria uma relação polimórfica já configurada .

Portanto, as relações seriam:

• Possui o formulário: users.id <-> form.user_id
• A equipe possui o formulário: users.team_id <-> form.team_id
• Tem permissões para um grupo que possui um formulário: permissible.user_id <-> users.id && permissible.permissible_type = 'App\Team'
• Tem permissões para uma equipe que possui um formulário: permissible.user_id <-> users.id && permissible.permissible_type = 'App\Group'
• Tem permissão para um formulário: permissible.user_id <-> users.id && permissible.permissible_type = 'App\From'

Simplifique a versão:

$teamMorphType  = Relation::getMorphedModel('team');
$groupMorphType = Relation::getMorphedModel('group');
$formMorphType  = Relation::getMorphedModel('form');

$permissible = [
    $teamMorphType  => [$user->team_id],
    $groupMorphType => [],
    $formMorphType  => [],
];

foreach ($user->permissible as $permissible) {
    switch ($permissible->permissible_type) {
        case $teamMorphType:
        case $groupMorphType:
        case $formMorphType:
            $permissible[$permissible->permissible_type][] = $permissible->permissible_id;
            break;
    }
}

$forms = Form::query()
             ->where('user_id', '=', $user->id)
             ->orWhereIn('id', $permissible[$fromMorphType])
             ->orWhereIn('team_id', $permissible[$teamMorphType])
             ->orWhereIn('group_id', $permissible[$groupMorphType])
             ->get();

Versão detalhada:

// Owns Form
// users.id <-> forms.user_id
$userId = $user->id;

// Team owns Form
// users.team_id <-> forms.team_id
// Initialise the array with a first value.
// The permissions polymorphic relationship will have other teams ids to look at
$teamIds = [$user->team_id];

// Groups owns Form was not mention, so I assume there is not such a relation in user.
// Just initialise the array without a first value.
$groupIds = [];

// Also initialise forms for permissions:
$formIds = [];

// Has permissions to a group that owns a Form
// permissible.user_id <-> users.id && permissible.permissible_type = 'App\Team'
$teamMorphType = Relation::getMorphedModel('team');
// Has permissions to a team that owns a Form
// permissible.user_id <-> users.id && permissible.permissible_type = 'App\Group'
$groupMorphType = Relation::getMorphedModel('group');
// Has permission to a Form
// permissible.user_id <-> users.id && permissible.permissible_type = 'App\Form'
$formMorphType = Relation::getMorphedModel('form');

// Get permissions
$permissibles = $user->permissible()->whereIn(
    'permissible_type',
    [$teamMorphType, $groupMorphType, $formMorphType]
)->get();

// If you don't have more permissible types other than those, then you can just:
// $permissibles = $user->permissible;

// Group the ids per type
foreach ($permissibles as $permissible) {
    switch ($permissible->permissible_type) {
        case $teamMorphType:
            $teamIds[] = $permissible->permissible_id;
            break;
        case $groupMorphType:
            $groupIds[] = $permissible->permissible_id;
            break;
        case $formMorphType:
            $formIds[] = $permissible->permissible_id;
            break;
    }
}

// In case the user and the team ids are repeated:
$teamIds = array_values(array_unique($teamIds));
// We assume that the rest of the values will not be repeated.

$forms = Form::query()
             ->where('user_id', '=', $userId)
             ->orWhereIn('id', $formIds)
             ->orWhereIn('team_id', $teamIds)
             ->orWhereIn('group_id', $groupIds)
             ->get();

Recursos utilizados:

Desempenho do banco de dados:

• Consultas ao banco de dados (excluindo o usuário): 2 ; um para obter o permitido e outro para obter os formulários.
• Sem junções !!
• As ORs mínimas possíveis ( user_id = ? OR id IN (?..) OR team_id IN (?...) OR group_id IN (?...).

PHP, na memória, desempenho:

• foreach looping o permissível com um interruptor dentro.
• array_values(array_unique()) para evitar repetir os IDs.
• Na memória, 3 matrizes de ids ( $teamIds, $groupIds,$formIds )
• Na memória, coleta eloquente de permissões relevantes (isso pode ser otimizado, se necessário).

Prós e contras

PROS:

• Tempo : a soma dos tempos de consultas únicas é menor que o tempo de uma grande consulta com junções e OR.
• Recursos de banco de dados : Os recursos MySQL usados ​​por uma consulta com instruções join e ou são maiores que os usados ​​pela soma de suas consultas separadas.
• Dinheiro : Menos recursos de banco de dados (processador, RAM, leitura de disco etc.), que são mais caros que os recursos PHP.
• Bloqueios : Caso você não esteja consultando um servidor escravo somente leitura, suas consultas criarão menos bloqueios de leitura de linhas (o bloqueio de leitura é compartilhado no MySQL, para que não bloqueie outra leitura, mas bloqueará qualquer gravação).
• Escalonável : essa abordagem permite fazer mais otimizações de desempenho, como agrupar as consultas.

CONTRAS:

• Recursos de código : fazer cálculos no código, e não no banco de dados, obviamente consumirá mais recursos na instância do código, mas principalmente na RAM, armazenando as informações do meio. No nosso caso, isso seria apenas uma matriz de IDs, o que não deveria ser realmente um problema.
• Manutenção : Se você usar as propriedades e os métodos do Laravel e fizer alguma alteração no banco de dados, será mais fácil atualizar o código do que se você fizer consultas e processamento mais explícitos.
• Overkilling? : Em alguns casos, se os dados não forem tão grandes, otimizar o desempenho pode ser um exagero.

Como medir o desempenho

Algumas dicas sobre como medir o desempenho?

1. Logs de consulta lentos
2. ANALISAR A TABELA
3. MOSTRAR O STATUS DA MESA COMO
4. EXPLIQUE ; Formato de saída EXPLAIN estendido ; usando explicar ; explicar saída
5. MOSTRAR AVISOS

Algumas ferramentas interessantes de criação de perfil:

• phpMyAdmin
• Resumo da consulta da Percona (resumo da consulta da pt)
• log-top

Por que você não pode simplesmente consultar os formulários necessários, em vez de fazer Form::all()e encadear umfilter() função após ela?

Igual a:

public function index() {
    $forms = $user->forms->merge($user->team->forms)->merge($user->permissible->groups->forms);
}

Então, sim, isso faz algumas consultas:

• Uma consulta para $user
• Um para $user->team
• Um para $user->team->forms
• Um para $user->permissible
• Um para $user->permissible->groups
• Um para $user->permissible->groups->forms

No entanto, o lado profissional é que você não precisa mais usar a política , pois conhece todos os formulários no$forms parâmetro são permitidos para o usuário.

Portanto, esta solução funcionará para qualquer quantidade de formulários que você tiver no banco de dados.

Uma observação sobre o uso merge()

merge()mescla as coleções e descartará os IDs de formulário duplicados que ele já encontrou. Portanto, se por algum motivo um formulário da teamrelação também é uma relação direta com ouser , ele será exibido apenas uma vez na coleção mesclada.

Isso ocorre porque na verdade é um Illuminate\Database\Eloquent\Collectionque tem sua própria merge()função que verifica os IDs do modelo Eloquent. Portanto, você não pode realmente usar esse truque ao mesclar 2 conteúdos diferentes de coleções como Postse Users, porque um usuário com id 3e uma postagem com id 3entrarão em conflito nesse caso, e somente este último (o Post) será encontrado na coleção mesclada.

Se você quiser que seja ainda mais rápido, crie uma consulta personalizada usando a fachada do banco de dados, algo como:

// Select forms based on a subquery that returns a list of id's.
$forms = Form::whereIn(
    'id',
    DB::select('id')->from('users')->where('users.id', $user->id)
        ->join('teams', 'users.id', '=', 'teams.user_id')
        ...
)->get();

Sua consulta real é muito maior, pois você tem muitas relações.

A principal melhoria de desempenho aqui vem do fato de que o trabalho pesado (a subconsulta) ignora completamente a lógica do modelo Eloquent. Tudo o que resta fazer é passar a lista de IDs para a whereInfunção para recuperar sua lista de Formobjetos.

Acredito que você possa usar o Lazy Collections para isso (Laravel 6.x) e carregar ansiosamente os relacionamentos antes que eles sejam acessados.

public function index(Request $request)
{
   // Eager Load relationships
   $request->user()->load(['forms', 'team.forms', 'permissible.group']);
   // Use cursor instead of all to return a LazyCollection instance
   $forms = Form::cursor()->filter(function($form) use ($request) {
         return $request->user()->can('view', $form);
   });
}

public function view(User $user, Form $form)
{
   return $user->forms->contains($form) ||
      $user->team->forms->contains($form) ||
      // $user->permissible->groups->forms($contains); // Assuming this line is a typo
      $user->permissible->groups->contains($form);
}