lib/SQL/Translator/Schema/Procedure.pm

   1 package SQL::Translator::Schema::Procedure;
   2
   3 =pod
   4
   5 =head1 NAME
   6
   7 SQL::Translator::Schema::Procedure - SQL::Translator procedure object
   8
   9 =head1 SYNOPSIS
  10
  11   use SQL::Translator::Schema::Procedure;
  12   my $procedure  = SQL::Translator::Schema::Procedure->new(
  13       name       => 'foo',
  14       sql        => 'CREATE PROC foo AS SELECT * FROM bar',
  15       parameters => 'foo,bar',
  16       owner      => 'nomar',
  17       comments   => 'blah blah blah',
  18       schema     => $schema,
  19   );
  20
  21 =head1 DESCRIPTION
  22
  23 C<SQL::Translator::Schema::Procedure> is a class for dealing with
  24 stored procedures (and possibly other pieces of nameable SQL code?).
  25
  26 =head1 METHODS
  27
  28 =cut
  29
  30 use Moo;
  31 use SQL::Translator::Utils qw(parse_list_arg ex2err);
  32 use SQL::Translator::Types qw(schema_obj);
  33 use List::MoreUtils qw(uniq);
  34
  35 with qw(
  36   SQL::Translator::Schema::Role::BuildArgs
  37   SQL::Translator::Schema::Role::Extra
  38   SQL::Translator::Schema::Role::Error
  39   SQL::Translator::Schema::Role::Compare
  40 );
  41
  42 our $VERSION = '1.59';
  43
  44 =head2 new
  45
  46 Object constructor.
  47
  48   my $schema = SQL::Translator::Schema::Procedure->new;
  49
  50 =cut
  51
  52 =head2 parameters
  53
  54 Gets and set the parameters of the stored procedure.
  55
  56   $procedure->parameters('id');
  57   $procedure->parameters('id', 'name');
  58   $procedure->parameters( 'id, name' );
  59   $procedure->parameters( [ 'id', 'name' ] );
  60   $procedure->parameters( qw[ id name ] );
  61
  62   my @parameters = $procedure->parameters;
  63
  64 =cut
  65
  66 has parameters => (
  67     is => 'rw',
  68     default => sub { [] },
  69     coerce => sub { [uniq @{parse_list_arg($_[0])}] },
  70 );
  71
  72 around parameters => sub {
  73     my $orig   = shift;
  74     my $self   = shift;
  75     my $fields = parse_list_arg( @_ );
  76     $self->$orig($fields) if @$fields;
  77
  78     return wantarray ? @{ $self->$orig } : $self->$orig;
  79 };
  80
  81 =head2 name
  82
  83 Get or set the procedure's name.
  84
  85   $procedure->name('foo');
  86   my $name = $procedure->name;
  87
  88 =cut
  89
  90 has name => ( is => 'rw', default => sub { '' } );
  91
  92 =head2 sql
  93
  94 Get or set the procedure's SQL.
  95
  96   $procedure->sql('select * from foo');
  97   my $sql = $procedure->sql;
  98
  99 =cut
 100
 101 has sql => ( is => 'rw', default => sub { '' } );
 102
 103 =head2 order
 104
 105 Get or set the order of the procedure.
 106
 107   $procedure->order( 3 );
 108   my $order = $procedure->order;
 109
 110 =cut
 111
 112 has order => ( is => 'rw' );
 113
 114
 115 =head2 owner
 116
 117 Get or set the owner of the procedure.
 118
 119   $procedure->owner('nomar');
 120   my $sql = $procedure->owner;
 121
 122 =cut
 123
 124 has owner => ( is => 'rw', default => sub { '' } );
 125
 126 =head2 comments
 127
 128 Get or set the comments on a procedure.
 129
 130   $procedure->comments('foo');
 131   $procedure->comments('bar');
 132   print join( ', ', $procedure->comments ); # prints "foo, bar"
 133
 134 =cut
 135
 136 has comments => (
 137     is => 'rw',
 138     coerce => sub { ref($_[0]) eq 'ARRAY' ? $_[0] : [$_[0]] },
 139     default => sub { [] },
 140 );
 141
 142 around comments => sub {
 143     my $orig     = shift;
 144     my $self     = shift;
 145     my @comments = ref $_[0] ? @{ $_[0] } : @_;
 146
 147     for my $arg ( @comments ) {
 148         $arg = $arg->[0] if ref $arg;
 149         push @{ $self->$orig }, $arg if defined $arg && $arg;
 150     }
 151
 152     return wantarray ? @{ $self->$orig } : join( "\n", @{ $self->$orig } );
 153 };
 154
 155 =head2 schema
 156
 157 Get or set the procedures's schema object.
 158
 159   $procedure->schema( $schema );
 160   my $schema = $procedure->schema;
 161
 162 =cut
 163
 164 has schema => ( is => 'rw', isa => schema_obj('Schema') );
 165
 166 around schema => \&ex2err;
 167
 168 =head2 equals
 169
 170 Determines if this procedure is the same as another
 171
 172   my $isIdentical = $procedure1->equals( $procedure2 );
 173
 174 =cut
 175
 176 around equals => sub {
 177     my $orig = shift;
 178     my $self = shift;
 179     my $other = shift;
 180     my $case_insensitive = shift;
 181     my $ignore_sql = shift;
 182
 183     return 0 unless $self->$orig($other);
 184     return 0 unless $case_insensitive ? uc($self->name) eq uc($other->name) : $self->name eq $other->name;
 185
 186     unless ($ignore_sql) {
 187         my $selfSql = $self->sql;
 188         my $otherSql = $other->sql;
 189         # Remove comments
 190         $selfSql =~ s/--.*$//mg;
 191         $otherSql =~ s/--.*$//mg;
 192         # Collapse whitespace to space to avoid whitespace comparison issues
 193         $selfSql =~ s/\s+/ /sg;
 194         $otherSql =~ s/\s+/ /sg;
 195         return 0 unless $selfSql eq $otherSql;
 196     }
 197
 198     return 0 unless $self->_compare_objects(scalar $self->parameters, scalar $other->parameters);
 199 #    return 0 unless $self->comments eq $other->comments;
 200 #    return 0 unless $case_insensitive ? uc($self->owner) eq uc($other->owner) : $self->owner eq $other->owner;
 201     return 0 unless $self->_compare_objects(scalar $self->extra, scalar $other->extra);
 202     return 1;
 203 };
 204
 205 sub DESTROY {
 206     my $self = shift;
 207     undef $self->{'schema'}; # destroy cyclical reference
 208 }
 209
 210 # Must come after all 'has' declarations
 211 around new => \&ex2err;
 212
 213 1;
 214
 215 =pod
 216
 217 =head1 AUTHORS
 218
 219 Ken Youens-Clark E<lt>kclark@cshl.orgE<gt>,
 220 Paul Harrington E<lt>Paul-Harrington@deshaw.comE<gt>.
 221
 222 =cut