view release on metacpan or  search on metacpan

lib/SQL/Engine/Grammar.pm  view on Meta::CPAN

  push @$sql, sprintf('(%s)', $self->name($data->{source}{column}));

  # references
  push @$sql, $self->term('references');

  # foreign table and column name
  push @$sql, sprintf('%s (%s)', $self->table($data->{target}),
    $self->name($data->{target}{column}));

  # reference option (on delete)
  if ($data->{on}{delete}) {
    push @$sql, $self->term(qw(on delete)),
      $self->constraint_option($data->{on}{delete});
  }

  # reference option (on update)
  if ($data->{on}{update}) {
    push @$sql, $self->term(qw(on update)),
      $self->constraint_option($data->{on}{update});
  }

  # sql statement
  my $result = join ' ', @$sql;

  return $self->operation($result);
}

method constraint_drop(HashRef $data) {
  my $sql = [];

  # alter table
  push @$sql, $self->term(qw(alter table));

  # safe
  push @$sql, $self->term(qw(if exists)) if $data->{safe};

  # table name
  push @$sql, $self->table($data->{source});

  # drop constraint
  push @$sql, $self->term(qw(drop constraint));

  # constraint name
  push @$sql, $self->name($self->constraint_name($data));

  # sql statement
  my $result = join ' ', @$sql;

  return $self->operation($result);
}

method constraint_name(HashRef $data) {

  return $data->{name} || join('_', 'foreign',
    join('_', grep {defined} @{$data->{source}}{qw(schema table column)}),
    join('_', grep {defined} @{$data->{target}}{qw(schema table column)})
  );
}

method constraint_option(Str $name) {
  if (lc($name) eq "cascade") {
    return $self->term('cascade');
  }
  elsif (lc($name) eq "no-action") {
    return $self->term(qw(no action));
  }
  elsif (lc($name) eq "restrict") {
    return $self->term('restrict');
  }
  elsif (lc($name) eq "set-default") {
    return $self->term(qw(set default));
  }
  elsif (lc($name) eq "set-null") {
    return $self->term(qw(set null));
  }
  else {
    return $self->term(qw(no action));
  }
}

method criteria(ArrayRef $data) {

  return [map $self->criterion($_), @$data];
}

method criterion(HashRef $data) {
  if (my $cond = $data->{"and"}) {
    return sprintf('(%s)',
      join(sprintf(' %s ', $self->term('and')), @{$self->criteria($cond)}));
  }

  if (my $cond = $data->{"eq"}) {
    return sprintf '%s = %s', map $self->expression($_), @$cond;
  }

  if (my $cond = $data->{"glob"}) {
    return sprintf '%s %s %s', $self->expression($cond->[0]),
      $self->term('glob'), $self->expression($cond->[1]);
  }

  if (my $cond = $data->{"gt"}) {
    return sprintf '%s > %s', map $self->expression($_), @$cond;
  }

  if (my $cond = $data->{"gte"}) {
    return sprintf '%s >= %s', map $self->expression($_), @$cond;
  }

  if (my $cond = $data->{"in"}) {
    return sprintf '%s %s %s', $self->expression($cond->[0]),
      $self->term('in'), join ', ', map $self->expression($_),
      @$cond[1 .. $#$cond];
  }

  if (my $cond = $data->{"is"}) {
    return sprintf '(%s)',
      (ref($cond) eq 'HASH')
        ? $self->expression($cond)
        : join(sprintf(' %s ', $self->term('and')), @{$self->criteria($cond)});
  }

  if (my $cond = $data->{"is-null"}) {