File Coverage

blib/lib/DBIx/Class/SQLA2.pm

Criterion	Covered	Total	%
statement	50	52	96.1
branch	10	16	62.5
condition	4	8	50.0
subroutine	13	13	100.0
pod	3	4	75.0
total	80	93	86.0

package DBIx::Class::SQLA2;
use strict;
use warnings;
use feature 'postderef';
no warnings 'experimental::postderef';
use mro 'c3';

use base qw(
  DBIx::Class::SQLMaker::ClassicExtensions
  SQL::Abstract
  SQL::Abstract::Classic
);

use Role::Tiny;

__PACKAGE__->mk_group_accessors(simple => '_connection_info');

sub _render_hashrefrefs {
  my ($self, $list) = @_;
  my @fields = ref $list eq 'ARRAY' ? @$list : $list;
  return [
    map {
      ref $_ eq 'REF' && ref $$_ eq 'HASH'
          ? do {
            my %f  = $$_->%*;
            my $as = delete $f{-as};
            \[
                $as
              ? $self->render_expr({ -op => [ 'as', \%f, { -ident => $as } ] })
              : $self->render_expr(\%f)
            ];
      }
          : $_
    } @fields
  ];
}

sub _recurse_fields {
  my ($self, $fields) = @_;
  if (ref $fields eq 'REF' && ref $$fields eq 'HASH') {
    return $self->next::method($self->_render_hashrefrefs($fields)->[0]);
  }
  return $self->next::method($fields);

}

sub select {
  my ($self, $table, $fields, $where, $rs_attrs, $limit, $offset) = @_;

  if (my $gb = $rs_attrs->{group_by}) {
    $rs_attrs = { %$rs_attrs, group_by => $self->_render_hashrefrefs($gb) };
  }
  $self->next::method($table, $fields, $where, $rs_attrs, $limit, $offset);
}


sub insert {
  # TODO - this works, ish. The issue is that if you have rels involved, you may actually
  # hit `insert` before the intended insert. Not sure what to do but put that on the
  # user...
  my ($self, $source, $cols, $attrs) = @_;
  $attrs ||= {};
  if (my $extra_attrs = $self->{_sqla2_insert_attrs}) {
    $attrs = { %$attrs, %$extra_attrs };
  }
  $self->next::method($source, $cols, $attrs);
}

sub expand_clause {
  my ($self, $clause, $value) = @_;
  my ($probably_key, $expanded) = $self->${ \$self->clause_expander($clause) }(undef, $value);
  if ($expanded) {
    return ($probably_key => $expanded);
  } else {
    return (undef => $probably_key);
  }
}

sub new {
  my $new = shift->next::method(@_);
  unless (grep {m/^with$/} $new->clauses_of('select')) {
    $new->plugin("+$_") for qw/ExtraClausesFixed WindowFunctions Upsert BangOverrides CaseExpr/;
  }
  return $new;
}

our $VERSION = '0.02_1';

1;

=encoding utf8

=head1 NAME

DBIx::Class::SQLA2 - SQL::Abstract v2 support in DBIx::Class

=head1 SYNOPSIS

 $schema->connect_call_rebase_sqlmaker('DBIx::Class::SQLA2');

=head1 DESCRIPTION

This is a work in progress for simplifying using SQLA2 with DBIC. This is for using w/ the
most recent version of DBIC.

For a simple way of using this, take a look at L.

In order to have inserts passthru SQLA2 keys, you should use the
L component, which allows you to add a C<-sqla2> key w/ a
hashref containing your passthroughs.

In order to support SQLA2 keys for bulk inserts (C), use the
L component. It adds a second arg to C which
allows you to add things to the final query (though you may get undefined behavior if
you're creating deep relationships - real world experience would be nice here). In
addition, it adds an C method to simplify the case of update on a primary
key conflict (see there for more details).

B

This role itself will add handling of hashref-refs to select lists + group by clauses,
which will render the inner hashref as if it had been passed through to SQLA2 rather than
doing the recursive function rendering that DBIC does.

=head2 Included Plugins

This will add the following SQLA2 plugins:

=over 2

=item L

Adds support for CTEs, and other fun new SQL syntax

=item L

Adds support for window functions and advanced aggregates.

=item L

Adds support for Upserts (ON CONFLICT clause)

=item L

Adds some hacky stuff so you can bypass/supplement DBIC's handling of certain clauses

=back

=head1 AUTHOR

Copyright (c) 2022-24 Veesh Goldman

=head1 LICENSE

This module is free software; you may copy this under the same
terms as perl itself (either the GNU General Public License or
the Artistic License)

=cut