diff --git a/lib/SQL/Translator/Parser/PostgreSQL.pm b/lib/SQL/Translator/Parser/PostgreSQL.pm index bad53189..558e0173 100644 --- a/lib/SQL/Translator/Parser/PostgreSQL.pm +++ b/lib/SQL/Translator/Parser/PostgreSQL.pm @@ -35,8 +35,7 @@ Table: CHECK (expression) | REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL ] [ ON DELETE action ] [ ON UPDATE action ] } - [ DEFERRABLE | NOT DEFERRABLE ] - [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] + [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] and table_constraint is: @@ -44,12 +43,11 @@ Table: { UNIQUE ( column_name [, ... ] ) | PRIMARY KEY ( column_name [, ... ] ) | CHECK ( expression ) | + EXCLUDE [USING acc_method] (expression) [INCLUDE (column [, ...])] [WHERE (predicate)] FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ] - [ MATCH FULL | MATCH PARTIAL ] - [ ON DELETE action ] [ ON UPDATE action ] } - [ DEFERRABLE | NOT DEFERRABLE ] - [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] + [ MATCH FULL | MATCH PARTIAL ] [ ON DELETE action ] [ ON UPDATE action ] } + [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] Index : (http://www.postgresql.org/docs/current/sql-createindex.html) @@ -317,6 +315,8 @@ using_method : /using/i WORD { $item[2] } where_predicate : /where/i /[^;]+/ +where_paren_predicate : /where/i '(' /[^;]+/ ')' + include_covering : /include/i '(' covering_field_name(s /,/) ')' { $item{'covering_field_name(s)'} } @@ -679,37 +679,38 @@ table_constraint : comment(s?) constraint_name(?) table_constraint_type deferrab my $fields = $desc->{'fields'}; my $expression = $desc->{'expression'}; my @comments = ( @{ $item[1] }, @{ $item[-1] } ); + my $expr_constraint = $type eq 'check' || $type eq 'exclude'; $return = { name => $item[2][0] || '', supertype => 'constraint', type => $type, - fields => $type ne 'check' ? $fields : [], - expression => $type eq 'check' ? $expression : '', + fields => $expr_constraint ? [] : $fields, + expression => $expr_constraint ? $expression : '', deferrable => $item{'deferrable'}, deferred => $item{'deferred'}, - reference_table => $desc->{'reference_table'}, - reference_fields => $desc->{'reference_fields'}, - match_type => $desc->{'match_type'}, on_delete => $desc->{'on_delete'} || $desc->{'on_delete_do'}, on_update => $desc->{'on_update'} || $desc->{'on_update_do'}, comments => [ @comments ], + %{$desc}{qw/include using where reference_table reference_fields match_type/} } } -table_constraint_type : /primary key/i '(' NAME(s /,/) ')' +table_constraint_type : /primary key/i '(' NAME(s /,/) ')' include_covering(?) { $return = { type => 'primary_key', fields => $item[3], + include => $item{'include_convering(?)'}[0], } } | - /unique/i '(' NAME(s /,/) ')' + /unique/i '(' NAME(s /,/) ')' include_covering(?) { $return = { type => 'unique', fields => $item[3], + include => $item{'include_convering(?)'}[0], } } | @@ -721,6 +722,16 @@ table_constraint_type : /primary key/i '(' NAME(s /,/) ')' } } | + /exclude/i using_method(?) '(' /[^)]+/ ')' include_covering(?) where_paren_predicate(?) { + $return = { + type => 'exclude', + expression => $item{__PATTERN2__}, + using => $item{'using_method(?)'}[0], + include => $item{'include_convering(?)'}[0], + where => $item{'where_paren_predicate(?)'}[0], + } + } + | /foreign key/i '(' NAME(s /,/) ')' /references/i table_id parens_word_list(?) match_type(?) key_action(s?) { my ( $on_delete, $on_update ); @@ -1119,6 +1130,10 @@ sub parse { } for my $cdata ( @{ $tdata->{'constraints'} || [] } ) { + my $options = [ + # load this up with the extras + map +{%{$cdata}{$_}}, grep $cdata->{$_}, qw/include using where/ + ]; my $constraint = $table->add_constraint( name => $cdata->{'name'}, type => $cdata->{'type'}, @@ -1129,6 +1144,7 @@ sub parse { on_delete => $cdata->{'on_delete'} || $cdata->{'on_delete_do'}, on_update => $cdata->{'on_update'} || $cdata->{'on_update_do'}, expression => $cdata->{'expression'}, + options => $options ) or die "Can't add constraint of type '" . $cdata->{'type'} . "' to table '" . $table->name . "': " . $table->error; diff --git a/lib/SQL/Translator/Producer/PostgreSQL.pm b/lib/SQL/Translator/Producer/PostgreSQL.pm index 16f5f44b..67e2dd98 100644 --- a/lib/SQL/Translator/Producer/PostgreSQL.pm +++ b/lib/SQL/Translator/Producer/PostgreSQL.pm @@ -204,6 +204,7 @@ and table_constraint is: { UNIQUE ( column_name [, ... ] ) | PRIMARY KEY ( column_name [, ... ] ) | CHECK ( expression ) | + EXCLUDE [USING acc_method] (expression) [INCLUDE (column [, ...])] [WHERE (predicate)] FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ] [ MATCH FULL | MATCH PARTIAL ] [ ON DELETE action ] [ ON UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE ] [ INITIALLY DEFERRED | INITIALLY IMMEDIATE ] @@ -615,6 +616,19 @@ sub create_geometry_constraints { return @constraints; } +sub _extract_extras_from_options { + my ($options_haver, $dispatcher) = @_; + for my $opt ($options_haver->options) { + if (ref $opt eq 'HASH') { + for my $key (keys %$opt) { + my $val = $opt->{$key}; + next unless defined $val; + $dispatcher->{lc $key}->($val); + } + } + } +} + { my %index_name; sub create_index @@ -636,26 +650,17 @@ sub create_geometry_constraints { return unless @fields; my %index_extras; - for my $opt ( $index->options ) { - if ( ref $opt eq 'HASH' ) { - foreach my $key (keys %$opt) { - my $value = $opt->{$key}; - next unless defined $value; - if ( uc($key) eq 'USING' ) { - $index_extras{using} = "USING $value"; - } - elsif ( uc($key) eq 'WHERE' ) { - $index_extras{where} = "WHERE $value"; - } - elsif ( uc($key) eq 'INCLUDE' ) { - next unless $postgres_version >= 11; - die 'Include list must be an arrayref' unless ref $value eq 'ARRAY'; - my $value_list = join ', ', @$value; - $index_extras{include} = "INCLUDE ($value_list)" - } - } + _extract_extras_from_options($index, { + using => sub { $index_extras{using} = "USING $_[0]" }, + where => sub { $index_extras{where} = "WHERE $_[0]" }, + include => sub { + my ($value) = @_; + return unless $postgres_version >= 11; + die 'Include list must be an arrayref' unless ref $value eq 'ARRAY'; + my $value_list = join ', ', @$value; + $index_extras{include} = "INCLUDE ($value_list)" } - } + }); my $def_start = 'CONSTRAINT ' . $generator->quote($name) . ' '; my $field_names = '(' . join(", ", (map { $_ =~ /\(.*\)/ ? $_ : ( $generator->quote($_) ) } @fields)) . ')'; @@ -684,8 +689,21 @@ sub create_constraint my ($c, $options) = @_; my $generator = _generator($options); + my $postgres_version = $options->{postgres_version} || 0; my $table_name = $c->table->name; my (@constraint_defs, @fks); + my %constraint_extras; + _extract_extras_from_options($c, { + using => sub { $constraint_extras{using} = "USING $_[0]" }, + where => sub { $constraint_extras{where} = "WHERE ( $_[0] )" }, + include => sub { + my ($value) = @_; + return unless $postgres_version >= 11; + die 'Include list must be an arrayref' unless ref $value eq 'ARRAY'; + my $value_list = join ', ', @$value; + $constraint_extras{include} = "INCLUDE ( $value_list )" + }, + }); my $name = $c->name || ''; @@ -693,22 +711,23 @@ sub create_constraint my @rfields = grep { defined } $c->reference_fields; - next if !@fields && $c->type ne CHECK_C; - my $def_start = $name ? 'CONSTRAINT ' . $generator->quote($name) . ' ' : ''; + return if !@fields && ($c->type ne CHECK_C && $c->type ne EXCLUDE); + my $def_start = $name ? 'CONSTRAINT ' . $generator->quote($name) : ''; my $field_names = '(' . join(", ", (map { $_ =~ /\(.*\)/ ? $_ : ( $generator->quote($_) ) } @fields)) . ')'; + my $include = $constraint_extras{include} || ''; if ( $c->type eq PRIMARY_KEY ) { - push @constraint_defs, "${def_start}PRIMARY KEY ".$field_names; + push @constraint_defs, join ' ', grep $_, $def_start, "PRIMARY KEY", $field_names, $include; } elsif ( $c->type eq UNIQUE ) { - push @constraint_defs, "${def_start}UNIQUE " .$field_names; + push @constraint_defs, join ' ', grep $_, $def_start, "UNIQUE", $field_names, $include; } elsif ( $c->type eq CHECK_C ) { my $expression = $c->expression; - push @constraint_defs, "${def_start}CHECK ($expression)"; + push @constraint_defs, join ' ', grep $_, $def_start, "CHECK ($expression)"; } elsif ( $c->type eq FOREIGN_KEY ) { - my $def .= "ALTER TABLE " . $generator->quote($table_name) . " ADD ${def_start}FOREIGN KEY $field_names" - . "\n REFERENCES " . $generator->quote($c->reference_table); + my $def .= join ' ', grep $_, "ALTER TABLE", $generator->quote($table_name), 'ADD', $def_start, "FOREIGN KEY $field_names"; + $def .= "\n REFERENCES " . $generator->quote($c->reference_table); if ( @rfields ) { $def .= ' (' . join( ', ', map { $generator->quote($_) } @rfields ) . ')'; @@ -733,6 +752,12 @@ sub create_constraint push @fks, "$def"; } + elsif( $c->type eq EXCLUDE ) { + my $using = $constraint_extras{using} || ''; + my $expression = $c->expression; + my $where = $constraint_extras{where} || ''; + push @constraint_defs, join ' ', grep $_, $def_start, 'EXCLUDE', $using, "( $expression )", $include, $where; + } return \@constraint_defs, \@fks; } diff --git a/lib/SQL/Translator/Schema/Constants.pm b/lib/SQL/Translator/Schema/Constants.pm index 4ad93894..1e648483 100644 --- a/lib/SQL/Translator/Schema/Constants.pm +++ b/lib/SQL/Translator/Schema/Constants.pm @@ -35,6 +35,8 @@ This module exports the following constants for Schema features; =item UNIQUE +=item EXCLUDE + =back =cut @@ -55,6 +57,7 @@ our @EXPORT = qw[ NULL PRIMARY_KEY UNIQUE + EXCLUDE ]; # @@ -78,6 +81,8 @@ use constant PRIMARY_KEY => 'PRIMARY KEY'; use constant UNIQUE => 'UNIQUE'; +use constant EXCLUDE => 'EXCLUDE'; + 1; =pod diff --git a/lib/SQL/Translator/Schema/Constraint.pm b/lib/SQL/Translator/Schema/Constraint.pm index a4833ee8..2b8d0941 100644 --- a/lib/SQL/Translator/Schema/Constraint.pm +++ b/lib/SQL/Translator/Schema/Constraint.pm @@ -40,6 +40,7 @@ my %VALID_CONSTRAINT_TYPE = ( CHECK_C, 1, FOREIGN_KEY, 1, NOT_NULL, 1, + EXCLUDE, 1, ); =head2 new diff --git a/t/14postgres-parser.t b/t/14postgres-parser.t index 9228861f..b4bae208 100644 --- a/t/14postgres-parser.t +++ b/t/14postgres-parser.t @@ -8,7 +8,7 @@ use SQL::Translator::Schema::Constants; use Test::SQL::Translator qw(maybe_plan); BEGIN { - maybe_plan(undef, 'SQL::Translator::Parser::PostgreSQL'); + maybe_plan( undef, 'SQL::Translator::Parser::PostgreSQL' ); SQL::Translator::Parser::PostgreSQL->import('parse'); } @@ -48,7 +48,8 @@ baz $foo$, f_int smallint, f_smallint smallint default (0)::smallint, primary key (f_id), - check (f_int between 1 and 5) + check (f_int between 1 and 5), + exclude using gist (f_int with =) INCLUDE (f_smallint) ); CREATE TABLE products_1 ( @@ -141,179 +142,199 @@ my @t1_fields = $t1->get_fields; is( scalar @t1_fields, 21, '21 fields in t_test1' ); my $f1 = shift @t1_fields; -is( $f1->name, 'f_serial', 'First field is "f_serial"' ); -is( $f1->data_type, 'integer', 'Field is an integer' ); -is( $f1->is_nullable, 0, 'Field cannot be null' ); -is( $f1->size, 11, 'Size is "11"' ); -is( $f1->default_value, '0', 'Default value is "0"' ); -is( $f1->is_primary_key, 1, 'Field is PK' ); -is( $f1->comments, 'this is the primary key', 'Comment' ); +is( $f1->name, 'f_serial', 'First field is "f_serial"' ); +is( $f1->data_type, 'integer', 'Field is an integer' ); +is( $f1->is_nullable, 0, 'Field cannot be null' ); +is( $f1->size, 11, 'Size is "11"' ); +is( $f1->default_value, '0', 'Default value is "0"' ); +is( $f1->is_primary_key, 1, 'Field is PK' ); +is( $f1->comments, 'this is the primary key', 'Comment' ); is( $f1->is_auto_increment, 1, 'Field is auto increment' ); my $f2 = shift @t1_fields; -is( $f2->name, 'f_varchar', 'Second field is "f_varchar"' ); -is( $f2->data_type, 'varchar', 'Field is a varchar' ); -is( $f2->is_nullable, 1, 'Field can be null' ); -is( $f2->size, 255, 'Size is "255"' ); -is( $f2->default_value, undef, 'Default value is undefined' ); -is( $f2->is_primary_key, 0, 'Field is not PK' ); -is( $f2->is_auto_increment, 0, 'Field is not auto increment' ); +is( $f2->name, 'f_varchar', 'Second field is "f_varchar"' ); +is( $f2->data_type, 'varchar', 'Field is a varchar' ); +is( $f2->is_nullable, 1, 'Field can be null' ); +is( $f2->size, 255, 'Size is "255"' ); +is( $f2->default_value, undef, 'Default value is undefined' ); +is( $f2->is_primary_key, 0, 'Field is not PK' ); +is( $f2->is_auto_increment, 0, 'Field is not auto increment' ); my $f3 = shift @t1_fields; -is( $f3->name, 'f_double', 'Third field is "f_double"' ); -is( $f3->data_type, 'float', 'Field is a float' ); -is( $f3->is_nullable, 1, 'Field can be null' ); -is( $f3->size, 20, 'Size is "20"' ); -is( $f3->default_value, undef, 'Default value is undefined' ); -is( $f3->is_primary_key, 0, 'Field is not PK' ); +is( $f3->name, 'f_double', 'Third field is "f_double"' ); +is( $f3->data_type, 'float', 'Field is a float' ); +is( $f3->is_nullable, 1, 'Field can be null' ); +is( $f3->size, 20, 'Size is "20"' ); +is( $f3->default_value, undef, 'Default value is undefined' ); +is( $f3->is_primary_key, 0, 'Field is not PK' ); my $f4 = shift @t1_fields; -is( $f4->name, 'f_bigint', 'Fourth field is "f_bigint"' ); -is( $f4->data_type, 'integer', 'Field is an integer' ); -is( $f4->is_nullable, 0, 'Field cannot be null' ); -is( $f4->size, 20, 'Size is "20"' ); -is( $f4->default_value, undef, 'Default value is undefined' ); -is( $f4->is_primary_key, 0, 'Field is not PK' ); +is( $f4->name, 'f_bigint', 'Fourth field is "f_bigint"' ); +is( $f4->data_type, 'integer', 'Field is an integer' ); +is( $f4->is_nullable, 0, 'Field cannot be null' ); +is( $f4->size, 20, 'Size is "20"' ); +is( $f4->default_value, undef, 'Default value is undefined' ); +is( $f4->is_primary_key, 0, 'Field is not PK' ); my $f5 = shift @t1_fields; -is( $f5->name, 'f_char', 'Fifth field is "f_char"' ); -is( $f5->data_type, 'char', 'Field is char' ); -is( $f5->is_nullable, 1, 'Field can be null' ); -is( $f5->size, 10, 'Size is "10"' ); -is( $f5->default_value, undef, 'Default value is undefined' ); -is( $f5->is_primary_key, 0, 'Field is not PK' ); +is( $f5->name, 'f_char', 'Fifth field is "f_char"' ); +is( $f5->data_type, 'char', 'Field is char' ); +is( $f5->is_nullable, 1, 'Field can be null' ); +is( $f5->size, 10, 'Size is "10"' ); +is( $f5->default_value, undef, 'Default value is undefined' ); +is( $f5->is_primary_key, 0, 'Field is not PK' ); my $f6 = shift @t1_fields; -is( $f6->name, 'f_bool', 'Sixth field is "f_bool"' ); -is( $f6->data_type, 'boolean', 'Field is a boolean' ); -is( $f6->is_nullable, 1, 'Field can be null' ); -is( $f6->size, 0, 'Size is "0"' ); -is( $f6->default_value, undef, 'Default value is undefined' ); -is( $f6->is_primary_key, 0, 'Field is not PK' ); +is( $f6->name, 'f_bool', 'Sixth field is "f_bool"' ); +is( $f6->data_type, 'boolean', 'Field is a boolean' ); +is( $f6->is_nullable, 1, 'Field can be null' ); +is( $f6->size, 0, 'Size is "0"' ); +is( $f6->default_value, undef, 'Default value is undefined' ); +is( $f6->is_primary_key, 0, 'Field is not PK' ); my $f7 = shift @t1_fields; -is( $f7->name, 'f_bin', 'Seventh field is "f_bin"' ); -is( $f7->data_type, 'bytea', 'Field is bytea' ); -is( $f7->is_nullable, 1, 'Field can be null' ); -is( $f7->size, 0, 'Size is "0"' ); -is( $f7->default_value, undef, 'Default value is undefined' ); -is( $f7->is_primary_key, 0, 'Field is not PK' ); +is( $f7->name, 'f_bin', 'Seventh field is "f_bin"' ); +is( $f7->data_type, 'bytea', 'Field is bytea' ); +is( $f7->is_nullable, 1, 'Field can be null' ); +is( $f7->size, 0, 'Size is "0"' ); +is( $f7->default_value, undef, 'Default value is undefined' ); +is( $f7->is_primary_key, 0, 'Field is not PK' ); my $f8 = shift @t1_fields; -is( $f8->name, 'f_tz', 'Eighth field is "f_tz"' ); -is( $f8->data_type, 'timestamp', 'Field is a timestamp' ); -is( $f8->is_nullable, 1, 'Field can be null' ); -is( $f8->size, 0, 'Size is "0"' ); -is( $f8->default_value, '1970-01-01 00:00:00', 'Default value is 1970-01-01 00:00:00' ); +is( $f8->name, 'f_tz', 'Eighth field is "f_tz"' ); +is( $f8->data_type, 'timestamp', 'Field is a timestamp' ); +is( $f8->is_nullable, 1, 'Field can be null' ); +is( $f8->size, 0, 'Size is "0"' ); +is( + $f8->default_value, + '1970-01-01 00:00:00', + 'Default value is 1970-01-01 00:00:00' +); is( $f8->is_primary_key, 0, 'Field is not PK' ); my $f9 = shift @t1_fields; -is( $f9->name, 'f_text', 'Ninth field is "f_text"' ); -is( $f9->data_type, 'text', 'Field is text' ); -is( $f9->is_nullable, 1, 'Field can be null' ); -is( $f9->size, 64000, 'Size is "64,000"' ); -is( $f9->default_value, " foo\n\$bar\$\nbaz ", 'Dollar-quoted default value is " foo\n$bar$\nbaz "' ); +is( $f9->name, 'f_text', 'Ninth field is "f_text"' ); +is( $f9->data_type, 'text', 'Field is text' ); +is( $f9->is_nullable, 1, 'Field can be null' ); +is( $f9->size, 64000, 'Size is "64,000"' ); +is( + $f9->default_value, + " foo\n\$bar\$\nbaz ", + 'Dollar-quoted default value is " foo\n$bar$\nbaz "' +); is( $f9->is_primary_key, 0, 'Field is not PK' ); my $f10 = shift @t1_fields; -is( $f10->name, 'f_fk1', 'Tenth field is "f_fk1"' ); -is( $f10->data_type, 'integer', 'Field is an integer' ); -is( $f10->is_nullable, 0, 'Field cannot be null' ); -is( $f10->size, 10, 'Size is "10"' ); -is( $f10->default_value, undef, 'Default value is undefined' ); -is( $f10->is_primary_key, 0, 'Field is not PK' ); -is( $f10->is_foreign_key, 1, 'Field is a FK' ); +is( $f10->name, 'f_fk1', 'Tenth field is "f_fk1"' ); +is( $f10->data_type, 'integer', 'Field is an integer' ); +is( $f10->is_nullable, 0, 'Field cannot be null' ); +is( $f10->size, 10, 'Size is "10"' ); +is( $f10->default_value, undef, 'Default value is undefined' ); +is( $f10->is_primary_key, 0, 'Field is not PK' ); +is( $f10->is_foreign_key, 1, 'Field is a FK' ); my $fk_ref1 = $f10->foreign_key_reference; isa_ok( $fk_ref1, 'SQL::Translator::Schema::Constraint', 'FK' ); is( $fk_ref1->reference_table, 't_test2', 'FK is to "t_test2" table' ); my $f11 = shift @t1_fields; is( $f11->name, 'f_timestamp', 'Eleventh field is "f_timestamp"' ); -is( $f11->data_type, 'timestamp with time zone', 'Field is a timestamp with time zone' ); -is( $f11->is_nullable, 1, 'Field can be null' ); -is( $f11->size, 0, 'Size is "0"' ); -is( $f11->default_value, undef, 'Default value is "undef"' ); -is( $f11->is_primary_key, 0, 'Field is not PK' ); -is( $f11->is_foreign_key, 0, 'Field is not FK' ); +is( + $f11->data_type, + 'timestamp with time zone', + 'Field is a timestamp with time zone' +); +is( $f11->is_nullable, 1, 'Field can be null' ); +is( $f11->size, 0, 'Size is "0"' ); +is( $f11->default_value, undef, 'Default value is "undef"' ); +is( $f11->is_primary_key, 0, 'Field is not PK' ); +is( $f11->is_foreign_key, 0, 'Field is not FK' ); my $f12 = shift @t1_fields; is( $f12->name, 'f_timestamp2', '12th field is "f_timestamp2"' ); -is( $f12->data_type, 'timestamp without time zone', 'Field is a timestamp without time zone' ); -is( $f12->is_nullable, 1, 'Field can be null' ); -is( $f12->size, 0, 'Size is "0"' ); -is( $f12->default_value, undef, 'Default value is "undef"' ); -is( $f12->is_primary_key, 0, 'Field is not PK' ); -is( $f12->is_foreign_key, 0, 'Field is not FK' ); +is( + $f12->data_type, + 'timestamp without time zone', + 'Field is a timestamp without time zone' +); +is( $f12->is_nullable, 1, 'Field can be null' ); +is( $f12->size, 0, 'Size is "0"' ); +is( $f12->default_value, undef, 'Default value is "undef"' ); +is( $f12->is_primary_key, 0, 'Field is not PK' ); +is( $f12->is_foreign_key, 0, 'Field is not FK' ); my $f13 = shift @t1_fields; -is( $f13->name, 'f_json', '13th field is "f_json"' ); -is( $f13->data_type, 'json', 'Field is Json' ); -is( $f13->is_nullable, 1, 'Field can be null' ); -is( $f13->size, 0, 'Size is "0"' ); -is( $f13->default_value, undef, 'Default value is "undef"' ); -is( $f13->is_primary_key, 0, 'Field is not PK' ); -is( $f13->is_foreign_key, 0, 'Field is not FK' ); +is( $f13->name, 'f_json', '13th field is "f_json"' ); +is( $f13->data_type, 'json', 'Field is Json' ); +is( $f13->is_nullable, 1, 'Field can be null' ); +is( $f13->size, 0, 'Size is "0"' ); +is( $f13->default_value, undef, 'Default value is "undef"' ); +is( $f13->is_primary_key, 0, 'Field is not PK' ); +is( $f13->is_foreign_key, 0, 'Field is not FK' ); my $f14 = shift @t1_fields; -is( $f14->name, 'f_hstore', '14th field is "f_hstore"' ); -is( $f14->data_type, 'hstore', 'Field is hstore' ); -is( $f14->is_nullable, 1, 'Field can be null' ); -is( $f14->size, 0, 'Size is "0"' ); -is( $f14->default_value, undef, 'Default value is "undef"' ); -is( $f14->is_primary_key, 0, 'Field is not PK' ); -is( $f14->is_foreign_key, 0, 'Field is not FK' ); +is( $f14->name, 'f_hstore', '14th field is "f_hstore"' ); +is( $f14->data_type, 'hstore', 'Field is hstore' ); +is( $f14->is_nullable, 1, 'Field can be null' ); +is( $f14->size, 0, 'Size is "0"' ); +is( $f14->default_value, undef, 'Default value is "undef"' ); +is( $f14->is_primary_key, 0, 'Field is not PK' ); +is( $f14->is_foreign_key, 0, 'Field is not FK' ); my $f15 = shift @t1_fields; -is( $f15->name, 'f_numarray', '15th field is "f_numarray"' ); -is( $f15->data_type, 'numeric[]', 'Field is numeric[]' ); -is( $f15->is_nullable, 1, 'Field can be null' ); -is_deeply( [$f15->size], [7,2] , 'Size is "7,2"' ); -is( $f15->default_value, undef, 'Default value is "undef"' ); -is( $f15->is_primary_key, 0, 'Field is not PK' ); -is( $f15->is_foreign_key, 0, 'Field is not FK' ); +is( $f15->name, 'f_numarray', '15th field is "f_numarray"' ); +is( $f15->data_type, 'numeric[]', 'Field is numeric[]' ); +is( $f15->is_nullable, 1, 'Field can be null' ); +is_deeply( [ $f15->size ], [ 7, 2 ], 'Size is "7,2"' ); +is( $f15->default_value, undef, 'Default value is "undef"' ); +is( $f15->is_primary_key, 0, 'Field is not PK' ); +is( $f15->is_foreign_key, 0, 'Field is not FK' ); my $f16 = shift @t1_fields; -is( $f16->name, 'f_uuid', '16th field is "f_uuid"' ); -is( $f16->data_type, 'uuid', 'Field is a UUID' ); -is( $f16->is_nullable, 1, 'Field can be null' ); -is( $f16->size, 0, 'Size is "0"' ); -is( $f16->default_value, undef, 'Default value is "undef"' ); -is( $f16->is_primary_key, 0, 'Field is not PK' ); -is( $f16->is_foreign_key, 0, 'Field is not FK' ); +is( $f16->name, 'f_uuid', '16th field is "f_uuid"' ); +is( $f16->data_type, 'uuid', 'Field is a UUID' ); +is( $f16->is_nullable, 1, 'Field can be null' ); +is( $f16->size, 0, 'Size is "0"' ); +is( $f16->default_value, undef, 'Default value is "undef"' ); +is( $f16->is_primary_key, 0, 'Field is not PK' ); +is( $f16->is_foreign_key, 0, 'Field is not FK' ); my $f17 = shift @t1_fields; -is( $f17->name, 'f_time', '17th field is "f_time"' ); +is( $f17->name, 'f_time', '17th field is "f_time"' ); is( $f17->data_type, 'time with time zone', 'Field is a time with time zone' ); -is( $f17->is_nullable, 1, 'Field can be null' ); -is( $f17->size, 0, 'Size is "0"' ); -is( $f17->default_value, undef, 'Default value is "undef"' ); -is( $f17->is_primary_key, 0, 'Field is not PK' ); -is( $f17->is_foreign_key, 0, 'Field is not FK' ); +is( $f17->is_nullable, 1, 'Field can be null' ); +is( $f17->size, 0, 'Size is "0"' ); +is( $f17->default_value, undef, 'Default value is "undef"' ); +is( $f17->is_primary_key, 0, 'Field is not PK' ); +is( $f17->is_foreign_key, 0, 'Field is not FK' ); my $f18 = shift @t1_fields; is( $f18->name, 'f_time2', '18th field is "f_time2"' ); -is( $f18->data_type, 'time without time zone', 'Field is a time without time zone' ); -is( $f18->is_nullable, 1, 'Field can be null' ); -is( $f18->size, 0, 'Size is "0"' ); -is( $f18->default_value, undef, 'Default value is "undef"' ); -is( $f18->is_primary_key, 0, 'Field is not PK' ); -is( $f18->is_foreign_key, 0, 'Field is not FK' ); +is( + $f18->data_type, + 'time without time zone', + 'Field is a time without time zone' +); +is( $f18->is_nullable, 1, 'Field can be null' ); +is( $f18->size, 0, 'Size is "0"' ); +is( $f18->default_value, undef, 'Default value is "undef"' ); +is( $f18->is_primary_key, 0, 'Field is not PK' ); +is( $f18->is_foreign_key, 0, 'Field is not FK' ); my $f19 = shift @t1_fields; -is( $f19->name, 'f_text2', '19th field is "f_text2"' ); -is( $f19->data_type, 'text', 'Field is text' ); -is( $f19->is_nullable, 1, 'Field can be null' ); -is( $f19->size, 64000, 'Size is "64,000"' ); -is( $f19->default_value, '', 'Dollar-quoted default value is empty' ); -is( $f19->is_primary_key, 0, 'Field is not PK' ); +is( $f19->name, 'f_text2', '19th field is "f_text2"' ); +is( $f19->data_type, 'text', 'Field is text' ); +is( $f19->is_nullable, 1, 'Field can be null' ); +is( $f19->size, 64000, 'Size is "64,000"' ); +is( $f19->default_value, '', 'Dollar-quoted default value is empty' ); +is( $f19->is_primary_key, 0, 'Field is not PK' ); my $f20 = shift @t1_fields; -is( $f20->name, 'f_text3', '20th field is "f_text3"' ); -is( $f20->data_type, 'text', 'Field is text' ); -is( $f20->is_nullable, 1, 'Field can be null' ); -is( $f20->size, 64000, 'Size is "64,000"' ); -is( $f20->default_value, '$ ', 'Dollar-quoted default value is "$ "' ); -is( $f20->is_primary_key, 0, 'Field is not PK' ); +is( $f20->name, 'f_text3', '20th field is "f_text3"' ); +is( $f20->data_type, 'text', 'Field is text' ); +is( $f20->is_nullable, 1, 'Field can be null' ); +is( $f20->size, 64000, 'Size is "64,000"' ); +is( $f20->default_value, '$ ', 'Dollar-quoted default value is "$ "' ); +is( $f20->is_primary_key, 0, 'Field is not PK' ); # my $fk_ref2 = $f11->foreign_key_reference; # isa_ok( $fk_ref2, 'SQL::Translator::Schema::Constraint', 'FK' ); @@ -323,28 +344,31 @@ my @t1_constraints = $t1->get_constraints; is( scalar @t1_constraints, 8, '8 constraints on t_test1' ); my $c1 = $t1_constraints[0]; -is( $c1->type, PRIMARY_KEY, 'First constraint is PK' ); -is( join(',', $c1->fields), 'f_serial', 'Constraint is on field "f_serial"' ); +is( $c1->type, PRIMARY_KEY, 'First constraint is PK' ); +is( join( ',', $c1->fields ), 'f_serial', 'Constraint is on field "f_serial"' ); my $c2 = $t1_constraints[4]; -is( $c2->type, FOREIGN_KEY, 'Second constraint is foreign key' ); -is( join(',', $c2->fields), 'f_fk1', 'Constraint is on field "f_fk1"' ); -is( $c2->reference_table, 't_test2', 'Constraint is to table "t_test2"' ); -is( join(',', $c2->reference_fields), 'f_id', 'Constraint is to field "f_id"' ); +is( $c2->type, FOREIGN_KEY, 'Second constraint is foreign key' ); +is( join( ',', $c2->fields ), 'f_fk1', 'Constraint is on field "f_fk1"' ); +is( $c2->reference_table, 't_test2', 'Constraint is to table "t_test2"' ); +is( join( ',', $c2->reference_fields ), + 'f_id', 'Constraint is to field "f_id"' ); my $c3 = $t1_constraints[5]; is( $c3->type, UNIQUE, 'Third constraint is unique' ); -is( join(',', $c3->fields), 'f_varchar', 'Constraint is on field "f_varchar"' ); +is( join( ',', $c3->fields ), + 'f_varchar', 'Constraint is on field "f_varchar"' ); my $c4 = $t1_constraints[6]; -is( $c4->type, FOREIGN_KEY, 'Fourth constraint is foreign key' ); -is( join(',', $c4->fields), 'f_fk2', 'Constraint is on field "f_fk2"' ); -is( $c4->reference_table, 't_test2', 'Constraint is to table "t_test2"' ); -is( join(',', $c4->reference_fields), 'f_id', 'Constraint is to field "f_id"' ); -is( $c4->on_delete, 'cascade', 'On delete: cascade' ); -is( $c4->on_update, 'no_action', 'On delete: no action' ); -is( $c4->match_type, 'simple', 'Match type: simple' ); -is( $c4->deferrable, 1, 'Deferrable detected' ); +is( $c4->type, FOREIGN_KEY, 'Fourth constraint is foreign key' ); +is( join( ',', $c4->fields ), 'f_fk2', 'Constraint is on field "f_fk2"' ); +is( $c4->reference_table, 't_test2', 'Constraint is to table "t_test2"' ); +is( join( ',', $c4->reference_fields ), + 'f_id', 'Constraint is to field "f_id"' ); +is( $c4->on_delete, 'cascade', 'On delete: cascade' ); +is( $c4->on_update, 'no_action', 'On delete: no action' ); +is( $c4->match_type, 'simple', 'Match type: simple' ); +is( $c4->deferrable, 1, 'Deferrable detected' ); my $t2 = shift @tables; is( $t2->name, 't_test2', 'Table t_test2 exists' ); @@ -353,40 +377,39 @@ my @t2_fields = $t2->get_fields; is( scalar @t2_fields, 4, '4 fields in t_test2' ); my $t2_f1 = shift @t2_fields; -is( $t2_f1->name, 'f_id', 'First field is "f_id"' ); -is( $t2_f1->data_type, 'integer', 'Field is an integer' ); -is( $t2_f1->is_nullable, 0, 'Field cannot be null' ); -is( $t2_f1->size, 10, 'Size is "10"' ); -is( $t2_f1->default_value, undef, 'Default value is undefined' ); -is( $t2_f1->is_primary_key, 1, 'Field is PK' ); +is( $t2_f1->name, 'f_id', 'First field is "f_id"' ); +is( $t2_f1->data_type, 'integer', 'Field is an integer' ); +is( $t2_f1->is_nullable, 0, 'Field cannot be null' ); +is( $t2_f1->size, 10, 'Size is "10"' ); +is( $t2_f1->default_value, undef, 'Default value is undefined' ); +is( $t2_f1->is_primary_key, 1, 'Field is PK' ); my $t2_f2 = shift @t2_fields; -is( $t2_f2->name, 'f_varchar', 'Second field is "f_varchar"' ); -is( $t2_f2->data_type, 'varchar', 'Field is an varchar' ); -is( $t2_f2->is_nullable, 1, 'Field can be null' ); -is( $t2_f2->size, 25, 'Size is "25"' ); -is( $t2_f2->default_value, undef, 'Default value is undefined' ); -is( $t2_f2->is_primary_key, 0, 'Field is not PK' ); +is( $t2_f2->name, 'f_varchar', 'Second field is "f_varchar"' ); +is( $t2_f2->data_type, 'varchar', 'Field is an varchar' ); +is( $t2_f2->is_nullable, 1, 'Field can be null' ); +is( $t2_f2->size, 25, 'Size is "25"' ); +is( $t2_f2->default_value, undef, 'Default value is undefined' ); +is( $t2_f2->is_primary_key, 0, 'Field is not PK' ); my $t2_f3 = shift @t2_fields; -is( $t2_f3->name, 'f_int', 'Third field is "f_int"' ); -is( $t2_f3->data_type, 'integer', 'Field is an integer' ); -is( $t2_f3->is_nullable, 1, 'Field can be null' ); -is( $t2_f3->size, 5, 'Size is "5"' ); -is( $t2_f3->default_value, undef, 'Default value is undefined' ); -is( $t2_f3->is_primary_key, 0, 'Field is not PK' ); +is( $t2_f3->name, 'f_int', 'Third field is "f_int"' ); +is( $t2_f3->data_type, 'integer', 'Field is an integer' ); +is( $t2_f3->is_nullable, 1, 'Field can be null' ); +is( $t2_f3->size, 5, 'Size is "5"' ); +is( $t2_f3->default_value, undef, 'Default value is undefined' ); +is( $t2_f3->is_primary_key, 0, 'Field is not PK' ); my $t2_f4 = shift @t2_fields; -is( $t2_f4->name, 'f_smallint', 'Fourth field is "f_smallint"' ); -is( $t2_f4->data_type, 'integer', 'Field is an integer' ); -is( $t2_f4->is_nullable, 1, 'Field can be null' ); -is( $t2_f4->size, 5, 'Size is "5"' ); -is( $t2_f4->default_value, 0, 'Default value is 0' ); -is( $t2_f4->is_primary_key, 0, 'Field is not PK' ); - +is( $t2_f4->name, 'f_smallint', 'Fourth field is "f_smallint"' ); +is( $t2_f4->data_type, 'integer', 'Field is an integer' ); +is( $t2_f4->is_nullable, 1, 'Field can be null' ); +is( $t2_f4->size, 5, 'Size is "5"' ); +is( $t2_f4->default_value, 0, 'Default value is 0' ); +is( $t2_f4->is_primary_key, 0, 'Field is not PK' ); my @t2_constraints = $t2->get_constraints; -is( scalar @t2_constraints, 3, "Three constraints on table" ); +is( scalar @t2_constraints, 4, "Three constraints on table" ); my $t2_c1 = shift @t2_constraints; is( $t2_c1->type, NOT_NULL, "Constraint is NOT NULL" ); @@ -396,38 +419,58 @@ is( $t2_c2->type, PRIMARY_KEY, "Constraint is a PK" ); my $t2_c3 = shift @t2_constraints; is( $t2_c3->type, CHECK_C, "Constraint is a 'CHECK'" ); +is $t2_c3->expression, 'f_int between 1 and 5', + 'expression is parsed for check constraint'; + +my $t2_c4 = shift @t2_constraints; +is( $t2_c4->type, EXCLUDE, "Constraint is an 'EXCLUDE'" ); +is $t2_c4->expression, 'f_int with =', + 'expression is parsed for exclude constraint'; +is_deeply [$t2_c4->options], [ { using => 'gist' } ], 'got the options right!'; # test temporary tables -is( exists $schema->get_table('products_1')->extra()->{'temporary'}, "", "Table is NOT temporary"); -is( $schema->get_table('products_2')->extra('temporary'), 1,"Table is TEMP"); -is( $schema->get_table('products_3')->extra('temporary'), 1,"Table is TEMPORARY"); +is( exists $schema->get_table('products_1')->extra()->{'temporary'}, + "", "Table is NOT temporary" ); +is( $schema->get_table('products_2')->extra('temporary'), 1, "Table is TEMP" ); +is( $schema->get_table('products_3')->extra('temporary'), + 1, "Table is TEMPORARY" ); # test trigger my $trigger = $schema->get_trigger('test_trigger'); -is( $trigger->on_table, 'products_1', "Trigger is on correct table"); -is_deeply( scalar $trigger->database_events, [qw(insert update delete)], "Correct events for trigger"); +is( $trigger->on_table, 'products_1', "Trigger is on correct table" ); +is_deeply( + scalar $trigger->database_events, + [qw(insert update delete)], + "Correct events for trigger" +); -is( $trigger->perform_action_when, 'before', "Correct time for trigger"); -is( $trigger->scope, 'row', "Correct scope for trigger"); -is( $trigger->action, 'EXECUTE PROCEDURE foo()', "Correct action for trigger"); +is( $trigger->perform_action_when, 'before', "Correct time for trigger" ); +is( $trigger->scope, 'row', "Correct scope for trigger" ); +is( $trigger->action, 'EXECUTE PROCEDURE foo()', "Correct action for trigger" ); # test index my @indices = $t1->get_indices; -is(scalar @indices, 4, 'got three indexes'); +is( scalar @indices, 4, 'got three indexes' ); my $t1_i1 = $indices[0]; -is( $t1_i1->name, 'test_index1', 'First index is "test_index1"' ); -is( join(',', $t1_i1->fields), 'f_varchar', 'Index is on field "f_varchar"' ); +is( $t1_i1->name, 'test_index1', 'First index is "test_index1"' ); +is( join( ',', $t1_i1->fields ), 'f_varchar', 'Index is on field "f_varchar"' ); is_deeply( [ $t1_i1->options ], [], 'Index is has no options' ); my $t1_i2 = $indices[1]; is( $t1_i2->name, 'test_index2', 'Second index is "test_index2"' ); -is( join(',', $t1_i2->fields), 'f_char,f_bool', 'Index is on fields "f_char, f_bool"' ); -is_deeply( [ $t1_i2->options ], [ { using => 'hash' } ], 'Index is using hash method' ); +is( join( ',', $t1_i2->fields ), + 'f_char,f_bool', 'Index is on fields "f_char, f_bool"' ); +is_deeply( + [ $t1_i2->options ], + [ { using => 'hash' } ], + 'Index is using hash method' +); my $t1_i3 = $indices[2]; is( $t1_i3->name, 'test_index3', 'Third index is "test_index3"' ); -is( join(',', $t1_i3->fields), 'f_bigint,f_tz', 'Index is on fields "f_bigint, f_tz"' ); +is( join( ',', $t1_i3->fields ), + 'f_bigint,f_tz', 'Index is on fields "f_bigint, f_tz"' ); is_deeply( [ $t1_i3->options ], [ { using => 'hash' }, { where => "f_bigint = '1' AND f_tz IS NULL" } ], @@ -436,13 +479,14 @@ is_deeply( my $t1_i4 = $indices[3]; is( $t1_i4->name, 'test_index4', 'Fourth index is "test_index4"' ); -is( join(',', $t1_i4->fields), 'f_bigint,f_tz', 'Index is on fields "f_bigint, f_tz"' ); +is( join( ',', $t1_i4->fields ), + 'f_bigint,f_tz', 'Index is on fields "f_bigint, f_tz"' ); is_deeply( [ $t1_i4->options ], [ - { using => 'hash' }, - { where => "f_bigint = '1' AND f_tz IS NULL" }, - { include => [ 'f_bool' ] } + { using => 'hash' }, + { where => "f_bigint = '1' AND f_tz IS NULL" }, + { include => ['f_bool'] } ], 'Index is using hash method and has predicate right and include INCLUDE' ); diff --git a/t/47postgres-producer.t b/t/47postgres-producer.t index e22903a8..5910946f 100644 --- a/t/47postgres-producer.t +++ b/t/47postgres-producer.t @@ -212,6 +212,22 @@ for my $name ( 'foo', undef ) { } } +subtest 'exclude constraints' => sub { + my $exclude_constraint = SQL::Translator::Schema::Constraint->new( + table => $table, + name => 'game', + expression => 'dates WITH &&, char with =', + options => { + using => 'gist', + where => 'fun IS TRUE', + }, + type => 'EXCLUDE', + ); + my ($def, undef) = SQL::Translator::Producer::PostgreSQL::create_constraint($exclude_constraint); + is $def->[0], 'CONSTRAINT game EXCLUDE USING gist ( dates WITH &&, char with = ) WHERE ( fun IS TRUE )', 'exclude constraint'; + +}; + my $alter_field = SQL::Translator::Producer::PostgreSQL::alter_field($field1, $field2); is($alter_field, qq[ALTER TABLE mytable ALTER COLUMN myfield SET NOT NULL;