[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / Storage / DBIHacks.pm

package   #hide from PAUSE
  DBIx::Class::Storage::DBIHacks;

#
# This module contains code that should never have seen the light of day,
# does not belong in the Storage, or is otherwise unfit for public
# display. The arrival of SQLA2 should immediately oboslete 90% of this
#

use strict;
use warnings;

use base 'DBIx::Class::Storage';
use mro 'c3';

use Carp::Clan qw/^DBIx::Class/;

#
# This code will remove non-selecting/non-restricting joins from
# {from} specs, aiding the RDBMS query optimizer
#
sub _prune_unused_joins {
  my ($self) = shift;

  my ($from, $select, $where, $attrs) = @_;

  if (ref $from ne 'ARRAY' || ref $from->[0] ne 'HASH' || ref $from->[1] ne 'ARRAY') {
    return $from;   # only standard {from} specs are supported
  }

  my $aliastypes = $self->_resolve_aliastypes_from_select_args(@_);

  # a grouped set will not be affected by amount of rows. Thus any
  # {multiplying} joins can go
  delete $aliastypes->{multiplying} if $attrs->{group_by};


  my @newfrom = $from->[0]; # FROM head is always present

  my %need_joins = (map { %{$_||{}} } (values %$aliastypes) );
  for my $j (@{$from}[1..$#$from]) {
    push @newfrom, $j if (
      (! $j->[0]{-alias}) # legacy crap
        ||
      $need_joins{$j->[0]{-alias}}
    );
  }

  return \@newfrom;
}

#
# This is the code producing joined subqueries like:
# SELECT me.*, other.* FROM ( SELECT me.* FROM ... ) JOIN other ON ... 
#
sub _adjust_select_args_for_complex_prefetch {
  my ($self, $from, $select, $where, $attrs) = @_;

  $self->throw_exception ('Nothing to prefetch... how did we get here?!')
    if not @{$attrs->{_prefetch_select}};

  $self->throw_exception ('Complex prefetches are not supported on resultsets with a custom from attribute')
    if (ref $from ne 'ARRAY' || ref $from->[0] ne 'HASH' || ref $from->[1] ne 'ARRAY');


  # generate inner/outer attribute lists, remove stuff that doesn't apply
  my $outer_attrs = { %$attrs };
  delete $outer_attrs->{$_} for qw/where bind rows offset group_by having/;

  my $inner_attrs = { %$attrs };
  delete $inner_attrs->{$_} for qw/for collapse _prefetch_select _collapse_order_by select as/;


  # bring over all non-collapse-induced order_by into the inner query (if any)
  # the outer one will have to keep them all
  delete $inner_attrs->{order_by};
  if (my $ord_cnt = @{$outer_attrs->{order_by}} - @{$outer_attrs->{_collapse_order_by}} ) {
    $inner_attrs->{order_by} = [
      @{$outer_attrs->{order_by}}[ 0 .. $ord_cnt - 1]
    ];
  }

  # generate the inner/outer select lists
  # for inside we consider only stuff *not* brought in by the prefetch
  # on the outside we substitute any function for its alias
  my $outer_select = [ @$select ];
  my $inner_select = [];
  for my $i (0 .. ( @$outer_select - @{$outer_attrs->{_prefetch_select}} - 1) ) {
    my $sel = $outer_select->[$i];

    if (ref $sel eq 'HASH' ) {
      $sel->{-as} ||= $attrs->{as}[$i];
      $outer_select->[$i] = join ('.', $attrs->{alias}, ($sel->{-as} || "inner_column_$i") );
    }

    push @$inner_select, $sel;
  }

  # construct the inner $from for the subquery
  # we need to prune first, because this will determine if we need a group_by below
  my $inner_from = $self->_prune_unused_joins ($from, $inner_select, $where, $inner_attrs);

  # if a multi-type join was needed in the subquery - add a group_by to simulate the
  # collapse in the subq
  $inner_attrs->{group_by} ||= $inner_select
    if List::Util::first
      { ! $_->[0]{-is_single} }
      (@{$inner_from}[1 .. $#$inner_from])
  ;

  # generate the subquery
  my $subq = $self->_select_args_to_query (
    $inner_from,
    $inner_select,
    $where,
    $inner_attrs,
  );

  my $subq_joinspec = {
    -alias => $attrs->{alias},
    -source_handle => $inner_from->[0]{-source_handle},
    $attrs->{alias} => $subq,
  };

  # Generate the outer from - this is relatively easy (really just replace
  # the join slot with the subquery), with a major caveat - we can not
  # join anything that is non-selecting (not part of the prefetch), but at
  # the same time is a multi-type relationship, as it will explode the result.
  #
  # There are two possibilities here
  # - either the join is non-restricting, in which case we simply throw it away
  # - it is part of the restrictions, in which case we need to collapse the outer
  #   result by tackling yet another group_by to the outside of the query

  # normalize a copy of $from, so it will be easier to work with further
  # down (i.e. promote the initial hashref to an AoH)
  $from = [ @$from ];
  $from->[0] = [ $from->[0] ];

  # so first generate the outer_from, up to the substitution point
  my @outer_from;
  while (my $j = shift @$from) {
    if ($j->[0]{-alias} eq $attrs->{alias}) { # time to swap
      push @outer_from, [
        $subq_joinspec,
        @{$j}[1 .. $#$j],
      ];
      last; # we'll take care of what's left in $from below
    }
    else {
      push @outer_from, $j;
    }
  }

  # scan the from spec against different attributes, and see which joins are needed
  # in what role
  my $outer_aliastypes =
    $self->_resolve_aliastypes_from_select_args( $from, $outer_select, $where, $outer_attrs );

  # see what's left - throw away if not selecting/restricting
  # also throw in a group_by if restricting to guard against
  # cross-join explosions
  #
  while (my $j = shift @$from) {
    my $alias = $j->[0]{-alias};

    if ($outer_aliastypes->{selecting}{$alias}) {
      push @outer_from, $j;
    }
    elsif ($outer_aliastypes->{restricting}{$alias}) {
      push @outer_from, $j;
      $outer_attrs->{group_by} ||= $outer_select unless $j->[0]{-is_single};
    }
  }

  # demote the outer_from head
  $outer_from[0] = $outer_from[0][0];

  # This is totally horrific - the $where ends up in both the inner and outer query
  # Unfortunately not much can be done until SQLA2 introspection arrives, and even
  # then if where conditions apply to the *right* side of the prefetch, you may have
  # to both filter the inner select (e.g. to apply a limit) and then have to re-filter
  # the outer select to exclude joins you didin't want in the first place
  #
  # OTOH it can be seen as a plus: <ash> (notes that this query would make a DBA cry ;)
  return (\@outer_from, $outer_select, $where, $outer_attrs);
}

#
# I KNOW THIS SUCKS! GET SQLA2 OUT THE DOOR SO THIS CAN DIE!
#
# Due to a lack of SQLA2 we fall back to crude scans of all the
# select/where/order/group attributes, in order to determine what
# aliases are neded to fulfill the query. This information is used
# throughout the code to prune unnecessary JOINs from the queries
# in an attempt to reduce the execution time.
# Although the method is pretty horrific, the worst thing that can
# happen is for it to fail due to some scalar SQL, which in turn will
# result in a vocal exception.
sub _resolve_aliastypes_from_select_args {
  my ( $self, $from, $select, $where, $attrs ) = @_;

  $self->throw_exception ('Unable to analyze custom {from}')
    if ref $from ne 'ARRAY';

  # what we will return
  my $aliases_by_type;

  # see what aliases are there to work with
  my $alias_list;
  for (@$from) {
    my $j = $_;
    $j = $j->[0] if ref $j eq 'ARRAY';
    my $al = $j->{-alias}
      or next;

    $alias_list->{$al} = $j;
    $aliases_by_type->{multiplying}{$al} = 1
      unless $j->{-is_single};
  }

  # get a column to source/alias map (including unqualified ones)
  my $colinfo = $self->_resolve_column_info ($from);

  # set up a botched SQLA
  my $sql_maker = $self->sql_maker;
  my $sep = quotemeta ($self->_sql_maker_opts->{name_sep} || '.');

  my ($orig_lquote, $orig_rquote) = map { quotemeta $_ } (do {
    if (ref $sql_maker->{quote_char} eq 'ARRAY') {
      @{$sql_maker->{quote_char}}
    }
    else {
      ($sql_maker->{quote_char} || '') x 2;
    }
  });

  local $sql_maker->{quote_char} = "\x00"; # so that we can regex away

  # generate sql chunks
  my $to_scan = {
    restricting => [
      $sql_maker->_recurse_where ($where),
      $sql_maker->_order_by({
        map { $_ => $attrs->{$_} } (qw/group_by having/)
      }),
    ],
    selecting => [
      $self->_parse_order_by ($attrs->{order_by}, $sql_maker),
      $sql_maker->_recurse_fields ($select),
    ],
  };

  # throw away empty chunks
  $_ = [ map { $_ || () } @$_ ] for values %$to_scan;

  # first loop through all fully qualified columns and get the corresponding
  # alias (should work even if they are in scalarrefs)
  for my $alias (keys %$alias_list) {
    my $al_re = qr/
      \x00 $alias \x00 $sep
        |
      \b $alias $sep
    /x;

    # add matching for possible quoted literal sql
    $al_re = qr/ $al_re | $orig_lquote $alias $orig_rquote /x
      if ($orig_lquote && $orig_rquote);


    for my $type (keys %$to_scan) {
      for my $piece (@{$to_scan->{$type}}) {
        $aliases_by_type->{$type}{$alias} = 1 if ($piece =~ $al_re);
      }
    }
  }

  # now loop through unqualified column names, and try to locate them within
  # the chunks
  for my $col (keys %$colinfo) {
    next if $col =~ $sep;   # if column is qualified it was caught by the above

    my $col_re = qr/ \x00 $col \x00 /x;

    $col_re = qr/ $col_re | $orig_lquote $col $orig_rquote /x
      if ($orig_lquote && $orig_rquote);

    for my $type (keys %$to_scan) {
      for my $piece (@{$to_scan->{$type}}) {
        $aliases_by_type->{$type}{$colinfo->{$col}{-source_alias}} = 1 if ($piece =~ $col_re);
      }
    }
  }

  # Add any non-left joins to the restriction list (such joins are indeed restrictions)
  for my $j (values %$alias_list) {
    my $alias = $j->{-alias} or next;
    $aliases_by_type->{restricting}{$alias} = 1 if (
      (not $j->{-join_type})
        or
      ($j->{-join_type} !~ /^left (?: \s+ outer)? $/xi)
    );
  }

  # mark all join parents as mentioned
  # (e.g.  join => { cds => 'tracks' } - tracks will need to bring cds too )
  for my $type (keys %$aliases_by_type) {
    for my $alias (keys %{$aliases_by_type->{$type}}) {
      $aliases_by_type->{$type}{$_} = 1
        for (map { values %$_ } @{ $alias_list->{$alias}{-join_path} || [] });
    }
  }

  return $aliases_by_type;
}

sub _resolve_ident_sources {
  my ($self, $ident) = @_;

  my $alias2source = {};
  my $rs_alias;

  # the reason this is so contrived is that $ident may be a {from}
  # structure, specifying multiple tables to join
  if ( Scalar::Util::blessed($ident) && $ident->isa("DBIx::Class::ResultSource") ) {
    # this is compat mode for insert/update/delete which do not deal with aliases
    $alias2source->{me} = $ident;
    $rs_alias = 'me';
  }
  elsif (ref $ident eq 'ARRAY') {

    for (@$ident) {
      my $tabinfo;
      if (ref $_ eq 'HASH') {
        $tabinfo = $_;
        $rs_alias = $tabinfo->{-alias};
      }
      if (ref $_ eq 'ARRAY' and ref $_->[0] eq 'HASH') {
        $tabinfo = $_->[0];
      }

      $alias2source->{$tabinfo->{-alias}} = $tabinfo->{-source_handle}->resolve
        if ($tabinfo->{-source_handle});
    }
  }

  return ($alias2source, $rs_alias);
}

# Takes $ident, \@column_names
#
# returns { $column_name => \%column_info, ... }
# also note: this adds -result_source => $rsrc to the column info
#
# If no columns_names are supplied returns info about *all* columns
# for all sources
sub _resolve_column_info {
  my ($self, $ident, $colnames) = @_;
  my ($alias2src, $root_alias) = $self->_resolve_ident_sources($ident);

  my $sep = $self->_sql_maker_opts->{name_sep} || '.';
  my $qsep = quotemeta $sep;

  my (%return, %seen_cols, @auto_colnames);

  # compile a global list of column names, to be able to properly
  # disambiguate unqualified column names (if at all possible)
  for my $alias (keys %$alias2src) {
    my $rsrc = $alias2src->{$alias};
    for my $colname ($rsrc->columns) {
      push @{$seen_cols{$colname}}, $alias;
      push @auto_colnames, "$alias$sep$colname" unless $colnames;
    }
  }

  $colnames ||= [
    @auto_colnames,
    grep { @{$seen_cols{$_}} == 1 } (keys %seen_cols),
  ];

  COLUMN:
  foreach my $col (@$colnames) {
    my ($alias, $colname) = $col =~ m/^ (?: ([^$qsep]+) $qsep)? (.+) $/x;

    unless ($alias) {
      # see if the column was seen exactly once (so we know which rsrc it came from)
      if ($seen_cols{$colname} and @{$seen_cols{$colname}} == 1) {
        $alias = $seen_cols{$colname}[0];
      }
      else {
        next COLUMN;
      }
    }

    my $rsrc = $alias2src->{$alias};
    $return{$col} = $rsrc && {
      %{$rsrc->column_info($colname)},
      -result_source => $rsrc,
      -source_alias => $alias,
    };
  }

  return \%return;
}

# The DBIC relationship chaining implementation is pretty simple - every
# new related_relationship is pushed onto the {from} stack, and the {select}
# window simply slides further in. This means that when we count somewhere
# in the middle, we got to make sure that everything in the join chain is an
# actual inner join, otherwise the count will come back with unpredictable
# results (a resultset may be generated with _some_ rows regardless of if
# the relation which the $rs currently selects has rows or not). E.g.
# $artist_rs->cds->count - normally generates:
# SELECT COUNT( * ) FROM artist me LEFT JOIN cd cds ON cds.artist = me.artistid
# which actually returns the number of artists * (number of cds || 1)
#
# So what we do here is crawl {from}, determine if the current alias is at
# the top of the stack, and if not - make sure the chain is inner-joined down
# to the root.
#
sub _straight_join_to_node {
  my ($self, $from, $alias) = @_;

  # subqueries and other oddness are naturally not supported
  return $from if (
    ref $from ne 'ARRAY'
      ||
    @$from <= 1
      ||
    ref $from->[0] ne 'HASH'
      ||
    ! $from->[0]{-alias}
      ||
    $from->[0]{-alias} eq $alias  # this last bit means $alias is the head of $from - nothing to do
  );

  # find the current $alias in the $from structure
  my $switch_branch;
  JOINSCAN:
  for my $j (@{$from}[1 .. $#$from]) {
    if ($j->[0]{-alias} eq $alias) {
      $switch_branch = $j->[0]{-join_path};
      last JOINSCAN;
    }
  }

  # something else went quite wrong
  return $from unless $switch_branch;

  # So it looks like we will have to switch some stuff around.
  # local() is useless here as we will be leaving the scope
  # anyway, and deep cloning is just too fucking expensive
  # So replace the first hashref in the node arrayref manually 
  my @new_from = ($from->[0]);
  my $sw_idx = { map { (values %$_), 1 } @$switch_branch }; #there's one k/v per join-path

  for my $j (@{$from}[1 .. $#$from]) {
    my $jalias = $j->[0]{-alias};

    if ($sw_idx->{$jalias}) {
      my %attrs = %{$j->[0]};
      delete $attrs{-join_type};
      push @new_from, [
        \%attrs,
        @{$j}[ 1 .. $#$j ],
      ];
    }
    else {
      push @new_from, $j;
    }
  }

  return \@new_from;
}

# Most databases do not allow aliasing of tables in UPDATE/DELETE. Thus
# a condition containing 'me' or other table prefixes will not work
# at all. What this code tries to do (badly) is introspect the condition
# and remove all column qualifiers. If it bails out early (returns undef)
# the calling code should try another approach (e.g. a subquery)
sub _strip_cond_qualifiers {
  my ($self, $where) = @_;

  my $cond = {};

  # No-op. No condition, we're updating/deleting everything
  return $cond unless $where;

  if (ref $where eq 'ARRAY') {
    $cond = [
      map {
        my %hash;
        foreach my $key (keys %{$_}) {
          $key =~ /([^.]+)$/;
          $hash{$1} = $_->{$key};
        }
        \%hash;
      } @$where
    ];
  }
  elsif (ref $where eq 'HASH') {
    if ( (keys %$where) == 1 && ( (keys %{$where})[0] eq '-and' )) {
      $cond->{-and} = [];
      my @cond = @{$where->{-and}};
       for (my $i = 0; $i < @cond; $i++) {
        my $entry = $cond[$i];
        my $hash;
        my $ref = ref $entry;
        if ($ref eq 'HASH' or $ref eq 'ARRAY') {
          $hash = $self->_strip_cond_qualifiers($entry);
        }
        elsif (! $ref) {
          $entry =~ /([^.]+)$/;
          $hash->{$1} = $cond[++$i];
        }
        else {
          $self->throw_exception ("_strip_cond_qualifiers() is unable to handle a condition reftype $ref");
        }
        push @{$cond->{-and}}, $hash;
      }
    }
    else {
      foreach my $key (keys %$where) {
        $key =~ /([^.]+)$/;
        $cond->{$1} = $where->{$key};
      }
    }
  }
  else {
    return undef;
  }

  return $cond;
}

sub _parse_order_by {
  my ($self, $order_by, $sql_maker) = @_;

  my $parser = sub {
    my ($sql_maker, $order_by) = @_;

    return scalar $sql_maker->_order_by_chunks ($order_by)
      unless wantarray;

    my @chunks;
    for my $chunk (map { ref $_ ? @$_ : $_ } ($sql_maker->_order_by_chunks ($order_by) ) ) {
      $chunk =~ s/\s+ (?: ASC|DESC ) \s* $//ix;
      push @chunks, $chunk;
    }

    return @chunks;
  };

  if ($sql_maker) {
    return $parser->($sql_maker, $order_by);
  }
  else {
    $sql_maker = $self->sql_maker;
    local $sql_maker->{quote_char};
    return $parser->($sql_maker, $order_by);
  }
}

1;
Commit	Line	Data
c443438f	1	package #hide from PAUSE
c443438f	2	DBIx::Class::Storage::DBIHacks;
d28bb90d	3
	4	#
	5	# This module contains code that should never have seen the light of day,
	6	# does not belong in the Storage, or is otherwise unfit for public
7eb76996	7	# display. The arrival of SQLA2 should immediately oboslete 90% of this
d28bb90d	8	#
	9
	10	use strict;
	11	use warnings;
	12
	13	use base 'DBIx::Class::Storage';
	14	use mro 'c3';
	15
	16	use Carp::Clan qw/^DBIx::Class/;
	17
	18	#
052e8431	19	# This code will remove non-selecting/non-restricting joins from
4b1b5ea3	20	# {from} specs, aiding the RDBMS query optimizer
052e8431	21	#
052e8431	22	sub _prune_unused_joins {
4b1b5ea3	23	my ($self) = shift;
	24
	25	my ($from, $select, $where, $attrs) = @_;
052e8431	26
052e8431	27	if (ref $from ne 'ARRAY' \|\| ref $from->[0] ne 'HASH' \|\| ref $from->[1] ne 'ARRAY') {
	28	return $from; # only standard {from} specs are supported
	29	}
	30
4b1b5ea3	31	my $aliastypes = $self->_resolve_aliastypes_from_select_args(@_);
	32
	33	# a grouped set will not be affected by amount of rows. Thus any
	34	# {multiplying} joins can go
	35	delete $aliastypes->{multiplying} if $attrs->{group_by};
	36
052e8431	37
	38	my @newfrom = $from->[0]; # FROM head is always present
	39
	40	my %need_joins = (map { %{$_\|\|{}} } (values %$aliastypes) );
	41	for my $j (@{$from}[1..$#$from]) {
539ffe87	42	push @newfrom, $j if (
4b1b5ea3	43	(! $j->[0]{-alias}) # legacy crap
539ffe87	44	\|\|
	45	$need_joins{$j->[0]{-alias}}
	46	);
052e8431	47	}
	48
	49	return \@newfrom;
	50	}
	51
052e8431	52	#
d28bb90d	53	# This is the code producing joined subqueries like:
	54	# SELECT me., other. FROM ( SELECT me.* FROM ... ) JOIN other ON ...
	55	#
	56	sub _adjust_select_args_for_complex_prefetch {
	57	my ($self, $from, $select, $where, $attrs) = @_;
	58
	59	$self->throw_exception ('Nothing to prefetch... how did we get here?!')
	60	if not @{$attrs->{_prefetch_select}};
	61
	62	$self->throw_exception ('Complex prefetches are not supported on resultsets with a custom from attribute')
	63	if (ref $from ne 'ARRAY' \|\| ref $from->[0] ne 'HASH' \|\| ref $from->[1] ne 'ARRAY');
	64
	65
	66	# generate inner/outer attribute lists, remove stuff that doesn't apply
	67	my $outer_attrs = { %$attrs };
	68	delete $outer_attrs->{$_} for qw/where bind rows offset group_by having/;
	69
	70	my $inner_attrs = { %$attrs };
	71	delete $inner_attrs->{$_} for qw/for collapse _prefetch_select _collapse_order_by select as/;
	72
	73
	74	# bring over all non-collapse-induced order_by into the inner query (if any)
	75	# the outer one will have to keep them all
	76	delete $inner_attrs->{order_by};
	77	if (my $ord_cnt = @{$outer_attrs->{order_by}} - @{$outer_attrs->{_collapse_order_by}} ) {
	78	$inner_attrs->{order_by} = [
	79	@{$outer_attrs->{order_by}}[ 0 .. $ord_cnt - 1]
	80	];
	81	}
	82
d28bb90d	83	# generate the inner/outer select lists
	84	# for inside we consider only stuff not brought in by the prefetch
	85	# on the outside we substitute any function for its alias
	86	my $outer_select = [ @$select ];
	87	my $inner_select = [];
	88	for my $i (0 .. ( @$outer_select - @{$outer_attrs->{_prefetch_select}} - 1) ) {
	89	my $sel = $outer_select->[$i];
	90
	91	if (ref $sel eq 'HASH' ) {
	92	$sel->{-as} \|\|= $attrs->{as}[$i];
	93	$outer_select->[$i] = join ('.', $attrs->{alias}, ($sel->{-as} \|\| "inner_column_$i") );
	94	}
	95
	96	push @$inner_select, $sel;
	97	}
	98
d28bb90d	99	# construct the inner $from for the subquery
48580715	100	# we need to prune first, because this will determine if we need a group_by below
052e8431	101	my $inner_from = $self->_prune_unused_joins ($from, $inner_select, $where, $inner_attrs);
ad630f4b	102
539ffe87	103	# if a multi-type join was needed in the subquery - add a group_by to simulate the
	104	# collapse in the subq
	105	$inner_attrs->{group_by} \|\|= $inner_select
	106	if List::Util::first
	107	{ ! $_->[0]{-is_single} }
	108	(@{$inner_from}[1 .. $#$inner_from])
	109	;
d28bb90d	110
d28bb90d	111	# generate the subquery
d28bb90d	112	my $subq = $self->_select_args_to_query (
052e8431	113	$inner_from,
d28bb90d	114	$inner_select,
	115	$where,
	116	$inner_attrs,
	117	);
	118
	119	my $subq_joinspec = {
	120	-alias => $attrs->{alias},
052e8431	121	-source_handle => $inner_from->[0]{-source_handle},
d28bb90d	122	$attrs->{alias} => $subq,
	123	};
	124
	125	# Generate the outer from - this is relatively easy (really just replace
	126	# the join slot with the subquery), with a major caveat - we can not
	127	# join anything that is non-selecting (not part of the prefetch), but at
	128	# the same time is a multi-type relationship, as it will explode the result.
	129	#
	130	# There are two possibilities here
	131	# - either the join is non-restricting, in which case we simply throw it away
	132	# - it is part of the restrictions, in which case we need to collapse the outer
	133	# result by tackling yet another group_by to the outside of the query
	134
052e8431	135	# normalize a copy of $from, so it will be easier to work with further
	136	# down (i.e. promote the initial hashref to an AoH)
	137	$from = [ @$from ];
	138	$from->[0] = [ $from->[0] ];
	139
d28bb90d	140	# so first generate the outer_from, up to the substitution point
	141	my @outer_from;
	142	while (my $j = shift @$from) {
	143	if ($j->[0]{-alias} eq $attrs->{alias}) { # time to swap
	144	push @outer_from, [
	145	$subq_joinspec,
	146	@{$j}[1 .. $#$j],
	147	];
	148	last; # we'll take care of what's left in $from below
	149	}
	150	else {
	151	push @outer_from, $j;
	152	}
	153	}
	154
052e8431	155	# scan the from spec against different attributes, and see which joins are needed
	156	# in what role
	157	my $outer_aliastypes =
539ffe87	158	$self->_resolve_aliastypes_from_select_args( $from, $outer_select, $where, $outer_attrs );
052e8431	159
d28bb90d	160	# see what's left - throw away if not selecting/restricting
	161	# also throw in a group_by if restricting to guard against
	162	# cross-join explosions
	163	#
	164	while (my $j = shift @$from) {
	165	my $alias = $j->[0]{-alias};
	166
1a736efb	167	if ($outer_aliastypes->{selecting}{$alias}) {
d28bb90d	168	push @outer_from, $j;
d28bb90d	169	}
1a736efb	170	elsif ($outer_aliastypes->{restricting}{$alias}) {
d28bb90d	171	push @outer_from, $j;
539ffe87	172	$outer_attrs->{group_by} \|\|= $outer_select unless $j->[0]{-is_single};
d28bb90d	173	}
	174	}
	175
	176	# demote the outer_from head
	177	$outer_from[0] = $outer_from[0][0];
	178
	179	# This is totally horrific - the $where ends up in both the inner and outer query
	180	# Unfortunately not much can be done until SQLA2 introspection arrives, and even
	181	# then if where conditions apply to the right side of the prefetch, you may have
	182	# to both filter the inner select (e.g. to apply a limit) and then have to re-filter
	183	# the outer select to exclude joins you didin't want in the first place
	184	#
	185	# OTOH it can be seen as a plus: <ash> (notes that this query would make a DBA cry ;)
	186	return (\@outer_from, $outer_select, $where, $outer_attrs);
	187	}
	188
1a736efb	189	#
	190	# I KNOW THIS SUCKS! GET SQLA2 OUT THE DOOR SO THIS CAN DIE!
	191	#
ad630f4b	192	# Due to a lack of SQLA2 we fall back to crude scans of all the
	193	# select/where/order/group attributes, in order to determine what
	194	# aliases are neded to fulfill the query. This information is used
	195	# throughout the code to prune unnecessary JOINs from the queries
	196	# in an attempt to reduce the execution time.
	197	# Although the method is pretty horrific, the worst thing that can
1a736efb	198	# happen is for it to fail due to some scalar SQL, which in turn will
1a736efb	199	# result in a vocal exception.
539ffe87	200	sub _resolve_aliastypes_from_select_args {
052e8431	201	my ( $self, $from, $select, $where, $attrs ) = @_;
546f1cd9	202
ad630f4b	203	$self->throw_exception ('Unable to analyze custom {from}')
ad630f4b	204	if ref $from ne 'ARRAY';
546f1cd9	205
ad630f4b	206	# what we will return
964a3c71	207	my $aliases_by_type;
546f1cd9	208
ad630f4b	209	# see what aliases are there to work with
ad630f4b	210	my $alias_list;
539ffe87	211	for (@$from) {
539ffe87	212	my $j = $_;
ad630f4b	213	$j = $j->[0] if ref $j eq 'ARRAY';
539ffe87	214	my $al = $j->{-alias}
	215	or next;
	216
	217	$alias_list->{$al} = $j;
	218	$aliases_by_type->{multiplying}{$al} = 1
	219	unless $j->{-is_single};
546f1cd9	220	}
546f1cd9	221
1a736efb	222	# get a column to source/alias map (including unqualified ones)
	223	my $colinfo = $self->_resolve_column_info ($from);
	224
ad630f4b	225	# set up a botched SQLA
	226	my $sql_maker = $self->sql_maker;
	227	my $sep = quotemeta ($self->_sql_maker_opts->{name_sep} \|\| '.');
07f31d19	228
1a736efb	229	my ($orig_lquote, $orig_rquote) = map { quotemeta $_ } (do {
	230	if (ref $sql_maker->{quote_char} eq 'ARRAY') {
	231	@{$sql_maker->{quote_char}}
	232	}
	233	else {
	234	($sql_maker->{quote_char} \|\| '') x 2;
	235	}
ad630f4b	236	});
07f31d19	237
1a736efb	238	local $sql_maker->{quote_char} = "\x00"; # so that we can regex away
	239
	240	# generate sql chunks
	241	my $to_scan = {
	242	restricting => [
	243	$sql_maker->_recurse_where ($where),
	244	$sql_maker->_order_by({
	245	map { $_ => $attrs->{$_} } (qw/group_by having/)
	246	}),
	247	],
	248	selecting => [
	249	$self->_parse_order_by ($attrs->{order_by}, $sql_maker),
	250	$sql_maker->_recurse_fields ($select),
	251	],
	252	};
	253
	254	# throw away empty chunks
	255	$_ = [ map { $_ \|\| () } @$_ ] for values %$to_scan;
	256
	257	# first loop through all fully qualified columns and get the corresponding
	258	# alias (should work even if they are in scalarrefs)
ad630f4b	259	for my $alias (keys %$alias_list) {
1a736efb	260	my $al_re = qr/
	261	\x00 $alias \x00 $sep
	262	\|
	263	\b $alias $sep
	264	/x;
	265
	266	# add matching for possible quoted literal sql
	267	$al_re = qr/ $al_re \| $orig_lquote $alias $orig_rquote /x
	268	if ($orig_lquote && $orig_rquote);
07f31d19	269
1a736efb	270
	271	for my $type (keys %$to_scan) {
	272	for my $piece (@{$to_scan->{$type}}) {
	273	$aliases_by_type->{$type}{$alias} = 1 if ($piece =~ $al_re);
	274	}
ad630f4b	275	}
1a736efb	276	}
	277
	278	# now loop through unqualified column names, and try to locate them within
	279	# the chunks
	280	for my $col (keys %$colinfo) {
	281	next if $col =~ $sep; # if column is qualified it was caught by the above
	282
	283	my $col_re = qr/ \x00 $col \x00 /x;
	284
	285	$col_re = qr/ $col_re \| $orig_lquote $col $orig_rquote /x
	286	if ($orig_lquote && $orig_rquote);
	287
	288	for my $type (keys %$to_scan) {
	289	for my $piece (@{$to_scan->{$type}}) {
	290	$aliases_by_type->{$type}{$colinfo->{$col}{-source_alias}} = 1 if ($piece =~ $col_re);
	291	}
07f31d19	292	}
	293	}
	294
	295	# Add any non-left joins to the restriction list (such joins are indeed restrictions)
ad630f4b	296	for my $j (values %$alias_list) {
07f31d19	297	my $alias = $j->{-alias} or next;
1a736efb	298	$aliases_by_type->{restricting}{$alias} = 1 if (
07f31d19	299	(not $j->{-join_type})
	300	or
	301	($j->{-join_type} !~ /^left (?: \s+ outer)? $/xi)
	302	);
	303	}
	304
	305	# mark all join parents as mentioned
	306	# (e.g. join => { cds => 'tracks' } - tracks will need to bring cds too )
964a3c71	307	for my $type (keys %$aliases_by_type) {
	308	for my $alias (keys %{$aliases_by_type->{$type}}) {
	309	$aliases_by_type->{$type}{$_} = 1
faeb2407	310	for (map { values %$_ } @{ $alias_list->{$alias}{-join_path} \|\| [] });
07f31d19	311	}
07f31d19	312	}
ad630f4b	313
964a3c71	314	return $aliases_by_type;
07f31d19	315	}
07f31d19	316
d28bb90d	317	sub _resolve_ident_sources {
	318	my ($self, $ident) = @_;
	319
	320	my $alias2source = {};
	321	my $rs_alias;
	322
	323	# the reason this is so contrived is that $ident may be a {from}
	324	# structure, specifying multiple tables to join
	325	if ( Scalar::Util::blessed($ident) && $ident->isa("DBIx::Class::ResultSource") ) {
	326	# this is compat mode for insert/update/delete which do not deal with aliases
	327	$alias2source->{me} = $ident;
	328	$rs_alias = 'me';
	329	}
	330	elsif (ref $ident eq 'ARRAY') {
	331
	332	for (@$ident) {
	333	my $tabinfo;
	334	if (ref $_ eq 'HASH') {
	335	$tabinfo = $_;
	336	$rs_alias = $tabinfo->{-alias};
	337	}
	338	if (ref $_ eq 'ARRAY' and ref $_->[0] eq 'HASH') {
	339	$tabinfo = $_->[0];
	340	}
	341
	342	$alias2source->{$tabinfo->{-alias}} = $tabinfo->{-source_handle}->resolve
	343	if ($tabinfo->{-source_handle});
	344	}
	345	}
	346
	347	return ($alias2source, $rs_alias);
	348	}
	349
	350	# Takes $ident, \@column_names
	351	#
	352	# returns { $column_name => \%column_info, ... }
	353	# also note: this adds -result_source => $rsrc to the column info
	354	#
09e14fdc	355	# If no columns_names are supplied returns info about all columns
09e14fdc	356	# for all sources
d28bb90d	357	sub _resolve_column_info {
	358	my ($self, $ident, $colnames) = @_;
	359	my ($alias2src, $root_alias) = $self->_resolve_ident_sources($ident);
	360
	361	my $sep = $self->_sql_maker_opts->{name_sep} \|\| '.';
09e14fdc	362	my $qsep = quotemeta $sep;
d28bb90d	363
09e14fdc	364	my (%return, %seen_cols, @auto_colnames);
d28bb90d	365
	366	# compile a global list of column names, to be able to properly
	367	# disambiguate unqualified column names (if at all possible)
	368	for my $alias (keys %$alias2src) {
	369	my $rsrc = $alias2src->{$alias};
	370	for my $colname ($rsrc->columns) {
	371	push @{$seen_cols{$colname}}, $alias;
09e14fdc	372	push @auto_colnames, "$alias$sep$colname" unless $colnames;
d28bb90d	373	}
	374	}
	375
09e14fdc	376	$colnames \|\|= [
	377	@auto_colnames,
	378	grep { @{$seen_cols{$_}} == 1 } (keys %seen_cols),
	379	];
	380
d28bb90d	381	COLUMN:
d28bb90d	382	foreach my $col (@$colnames) {
09e14fdc	383	my ($alias, $colname) = $col =~ m/^ (?: ([^$qsep]+) $qsep)? (.+) $/x;
d28bb90d	384
	385	unless ($alias) {
	386	# see if the column was seen exactly once (so we know which rsrc it came from)
	387	if ($seen_cols{$colname} and @{$seen_cols{$colname}} == 1) {
	388	$alias = $seen_cols{$colname}[0];
	389	}
	390	else {
	391	next COLUMN;
	392	}
	393	}
	394
	395	my $rsrc = $alias2src->{$alias};
	396	$return{$col} = $rsrc && {
	397	%{$rsrc->column_info($colname)},
	398	-result_source => $rsrc,
	399	-source_alias => $alias,
	400	};
	401	}
	402
	403	return \%return;
	404	}
	405
289ac713	406	# The DBIC relationship chaining implementation is pretty simple - every
	407	# new related_relationship is pushed onto the {from} stack, and the {select}
	408	# window simply slides further in. This means that when we count somewhere
	409	# in the middle, we got to make sure that everything in the join chain is an
	410	# actual inner join, otherwise the count will come back with unpredictable
	411	# results (a resultset may be generated with _some_ rows regardless of if
	412	# the relation which the $rs currently selects has rows or not). E.g.
	413	# $artist_rs->cds->count - normally generates:
	414	# SELECT COUNT( * ) FROM artist me LEFT JOIN cd cds ON cds.artist = me.artistid
	415	# which actually returns the number of artists * (number of cds \|\| 1)
	416	#
	417	# So what we do here is crawl {from}, determine if the current alias is at
	418	# the top of the stack, and if not - make sure the chain is inner-joined down
	419	# to the root.
	420	#
	421	sub _straight_join_to_node {
	422	my ($self, $from, $alias) = @_;
	423
	424	# subqueries and other oddness are naturally not supported
	425	return $from if (
	426	ref $from ne 'ARRAY'
	427	\|\|
	428	@$from <= 1
	429	\|\|
	430	ref $from->[0] ne 'HASH'
	431	\|\|
	432	! $from->[0]{-alias}
	433	\|\|
7eb76996	434	$from->[0]{-alias} eq $alias # this last bit means $alias is the head of $from - nothing to do
289ac713	435	);
	436
	437	# find the current $alias in the $from structure
	438	my $switch_branch;
	439	JOINSCAN:
	440	for my $j (@{$from}[1 .. $#$from]) {
	441	if ($j->[0]{-alias} eq $alias) {
	442	$switch_branch = $j->[0]{-join_path};
	443	last JOINSCAN;
	444	}
	445	}
	446
7eb76996	447	# something else went quite wrong
289ac713	448	return $from unless $switch_branch;
	449
	450	# So it looks like we will have to switch some stuff around.
	451	# local() is useless here as we will be leaving the scope
	452	# anyway, and deep cloning is just too fucking expensive
7eb76996	453	# So replace the first hashref in the node arrayref manually
289ac713	454	my @new_from = ($from->[0]);
faeb2407	455	my $sw_idx = { map { (values %$_), 1 } @$switch_branch }; #there's one k/v per join-path
289ac713	456
	457	for my $j (@{$from}[1 .. $#$from]) {
	458	my $jalias = $j->[0]{-alias};
	459
	460	if ($sw_idx->{$jalias}) {
	461	my %attrs = %{$j->[0]};
	462	delete $attrs{-join_type};
	463	push @new_from, [
	464	\%attrs,
	465	@{$j}[ 1 .. $#$j ],
	466	];
	467	}
	468	else {
	469	push @new_from, $j;
	470	}
	471	}
	472
	473	return \@new_from;
	474	}
	475
bac6c4fb	476	# Most databases do not allow aliasing of tables in UPDATE/DELETE. Thus
	477	# a condition containing 'me' or other table prefixes will not work
	478	# at all. What this code tries to do (badly) is introspect the condition
	479	# and remove all column qualifiers. If it bails out early (returns undef)
	480	# the calling code should try another approach (e.g. a subquery)
	481	sub _strip_cond_qualifiers {
	482	my ($self, $where) = @_;
	483
	484	my $cond = {};
	485
	486	# No-op. No condition, we're updating/deleting everything
	487	return $cond unless $where;
	488
	489	if (ref $where eq 'ARRAY') {
	490	$cond = [
	491	map {
	492	my %hash;
	493	foreach my $key (keys %{$_}) {
	494	$key =~ /([^.]+)$/;
	495	$hash{$1} = $_->{$key};
	496	}
	497	\%hash;
	498	} @$where
	499	];
	500	}
	501	elsif (ref $where eq 'HASH') {
	502	if ( (keys %$where) == 1 && ( (keys %{$where})[0] eq '-and' )) {
	503	$cond->{-and} = [];
	504	my @cond = @{$where->{-and}};
	505	for (my $i = 0; $i < @cond; $i++) {
	506	my $entry = $cond[$i];
	507	my $hash;
037e8dca	508	my $ref = ref $entry;
037e8dca	509	if ($ref eq 'HASH' or $ref eq 'ARRAY') {
bac6c4fb	510	$hash = $self->_strip_cond_qualifiers($entry);
bac6c4fb	511	}
037e8dca	512	elsif (! $ref) {
bac6c4fb	513	$entry =~ /([^.]+)$/;
	514	$hash->{$1} = $cond[++$i];
	515	}
037e8dca	516	else {
	517	$self->throw_exception ("_strip_cond_qualifiers() is unable to handle a condition reftype $ref");
	518	}
bac6c4fb	519	push @{$cond->{-and}}, $hash;
	520	}
	521	}
	522	else {
	523	foreach my $key (keys %$where) {
	524	$key =~ /([^.]+)$/;
	525	$cond->{$1} = $where->{$key};
	526	}
	527	}
	528	}
	529	else {
	530	return undef;
	531	}
	532
	533	return $cond;
	534	}
	535
c0748280	536	sub _parse_order_by {
1a736efb	537	my ($self, $order_by, $sql_maker) = @_;
c0748280	538
1a736efb	539	my $parser = sub {
1a736efb	540	my ($sql_maker, $order_by) = @_;
c0748280	541
1a736efb	542	return scalar $sql_maker->_order_by_chunks ($order_by)
1a736efb	543	unless wantarray;
c0748280	544
1a736efb	545	my @chunks;
	546	for my $chunk (map { ref $_ ? @$_ : $_ } ($sql_maker->_order_by_chunks ($order_by) ) ) {
	547	$chunk =~ s/\s+ (?: ASC\|DESC ) \s* $//ix;
	548	push @chunks, $chunk;
	549	}
	550
	551	return @chunks;
	552	};
	553
	554	if ($sql_maker) {
	555	return $parser->($sql_maker, $order_by);
	556	}
	557	else {
	558	$sql_maker = $self->sql_maker;
	559	local $sql_maker->{quote_char};
	560	return $parser->($sql_maker, $order_by);
	561	}
c0748280	562	}
bac6c4fb	563
d28bb90d	564	1;