[dbsrgits/SQL-Translator.git] / lib / SQL / Translator / Parser / SQLServer.pm

package SQL::Translator::Parser::SQLServer;

# -------------------------------------------------------------------
# Copyright (C) 2002-2009 SQLFairy Authors
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as
# published by the Free Software Foundation; version 2.
#
# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
# 02111-1307  USA
# -------------------------------------------------------------------

=head1 NAME

SQL::Translator::Parser::SQLServer - parser for SQL Server

=head1 SYNOPSIS

  use SQL::Translator::Parser::SQLServer;

=head1 DESCRIPTION

Adapted from Parser::Sybase and mostly parses the output of
Producer::SQLServer.  The parsing is by no means complete and
should probably be considered a work in progress.

=cut

use strict;

use vars qw[ $DEBUG $VERSION $GRAMMAR @EXPORT_OK ];
$VERSION = '1.59';
$DEBUG   = 0 unless defined $DEBUG;

use Data::Dumper;
use Parse::RecDescent;
use Exporter;
use base qw(Exporter);

@EXPORT_OK = qw(parse);

$::RD_ERRORS = 1;
$::RD_WARN   = 1;
$::RD_HINT   = 1;

$GRAMMAR = q{

{
    my ( %tables, @table_comments, $table_order, %procedures, $proc_order, %views, $view_order );

    sub _err {
      my $max_lines = 5;
      my @up_to_N_lines = split (/\n/, $_[1], $max_lines + 1);
      die sprintf ("Unable to parse line %d:\n%s\n",
        $_[0],
        join "\n", (map { "'$_'" } @up_to_N_lines[0..$max_lines - 1 ]), @up_to_N_lines > $max_lines ? '...' : ()
      );
    }

}

startrule : statement(s) eofile
   {
      return {
         tables     => \%tables,
         procedures => \%procedures,
         views      => \%views,
      }
   }

eofile : /^\Z/

statement : create_table
    | create_procedure
    | create_view
    | create_index
    | create_constraint
    | comment
    | disable_constraints
    | drop
    | use
    | setuser
    | if
    | print
    | grant
    | exec
    | /^\Z/ | { _err ($thisline, $text) }

use : /use/i WORD GO
    { @table_comments = () }

setuser : /setuser/i NAME GO

if : /if/i object_not_null begin if_command end GO

if_command : grant
    | create_index
    | create_constraint

object_not_null : /object_id/i '(' ident ')' /is not null/i

field_not_null : /where/i field_name /is \s+ not \s+ null/ix

print : /\s*/ /print/i /.*/

else : /else/i /.*/

begin : /begin/i

end : /end/i

grant : /grant/i /[^\n]*/

exec : exec_statement(s) GO

exec_statement : /exec/i /[^\n]+/

comment : /^\s*(?:#|-{2}).*\n/
    {
        my $comment =  $item[1];
        $comment    =~ s/^\s*(#|--)\s*//;
        $comment    =~ s/\s*$//;
        $return     = $comment;
        push @table_comments, $comment;
    }

comment : comment_start comment_middle comment_end
    {
        my $comment = $item[2];
        $comment =~ s/^\s*|\s*$//mg;
        $comment =~ s/^\**\s*//mg;
        push @table_comments, $comment;
    }

comment_start : m#^\s*\/\*#

comment_end : m#\s*\*\/#

comment_middle : m{([^*]+|\*(?!/))*}

drop : if_exists(?) /drop/i tbl_drop END_STATEMENT

tbl_drop : /table/i ident

if_exists : /if exists/i '(' /select/i 'name' /from/i 'sysobjects' /[^\)]+/ ')'

#
# Create table.
#
create_table : /create/i /table/i ident '(' create_def(s /,/) ')' lock(?) on_system(?) END_STATEMENT
    {
        my $table_owner = $item[3]{'owner'};
        my $table_name  = $item[3]{'name'};

        if ( @table_comments ) {
            $tables{ $table_name }{'comments'} = [ @table_comments ];
            @table_comments = ();
        }

        $tables{ $table_name }{'order'}  = ++$table_order;
        $tables{ $table_name }{'name'}   = $table_name;
        $tables{ $table_name }{'owner'}  = $table_owner;
        $tables{ $table_name }{'system'} = $item[7];

        my $i = 0;
        for my $def ( @{ $item[5] } ) {
            if ( $def->{'supertype'} eq 'field' ) {
                my $field_name = $def->{'name'};
                $tables{ $table_name }{'fields'}{ $field_name } =
                    { %$def, order => $i };
                $i++;

                if ( $def->{'is_primary_key'} ) {
                    push @{ $tables{ $table_name }{'constraints'} }, {
                        type   => 'primary_key',
                        fields => [ $field_name ],
                    };
                }
            }
            elsif ( $def->{'supertype'} eq 'constraint' ) {
                push @{ $tables{ $table_name }{'constraints'} }, $def;
            }
            else {
                push @{ $tables{ $table_name }{'indices'} }, $def;
            }
        }
    }

disable_constraints : if_exists(?) /alter/i /table/i ident /nocheck/i /constraint/i /all/i END_STATEMENT

# this is for the normal case 
create_constraint : /create/i constraint END_STATEMENT
    {
        @table_comments = ();
        push @{ $tables{ $item[2]{'table'} }{'constraints'} }, $item[2];
    }

# and this is for the BEGIN/END case
create_constraint : /create/i constraint
    {
        @table_comments = ();
        push @{ $tables{ $item[2]{'table'} }{'constraints'} }, $item[2];
    }


create_constraint : /alter/i /table/i ident /add/i foreign_key_constraint END_STATEMENT
    {
        push @{ $tables{ $item[3]{name} }{constraints} }, $item[5];
    }


create_index : /create/i index
    {
        @table_comments = ();
        push @{ $tables{ $item[2]{'table'} }{'indices'} }, $item[2];
    }

create_procedure : /create/i PROCEDURE WORD not_go GO
    {
        @table_comments = ();
        my $proc_name = $item[3];
        my $owner = '';
        my $sql = "$item[1] $item[2] $proc_name $item[4]";

        $procedures{ $proc_name }{'order'}  = ++$proc_order;
        $procedures{ $proc_name }{'name'}   = $proc_name;
        $procedures{ $proc_name }{'owner'}  = $owner;
        $procedures{ $proc_name }{'sql'}    = $sql;
    }

create_procedure : /create/i PROCEDURE '[' WORD '].' WORD not_go GO
    {
        @table_comments = ();
        my $proc_name = $item[6];
        my $owner = $item[4];
        my $sql = "$item[1] $item[2] [$owner].$proc_name $item[7]";

        $procedures{ $proc_name }{'order'}  = ++$proc_order;
        $procedures{ $proc_name }{'name'}   = $proc_name;
        $procedures{ $proc_name }{'owner'}  = $owner;
        $procedures{ $proc_name }{'sql'}    = $sql;
    }

PROCEDURE : /procedure/i
   | /function/i

create_view : /create/i /view/i WORD not_go GO
    {
        @table_comments = ();
        my $view_name = $item[3];
        my $sql = "$item[1] $item[2] $item[3] $item[4]";

        $views{ $view_name }{'order'}  = ++$view_order;
        $views{ $view_name }{'name'}   = $view_name;
        $views{ $view_name }{'sql'}    = $sql;
    }

not_go : /((?!\bgo\b).)*/is

create_def : constraint
    | index
    | field

blank : /\s*/

field : field_name data_type field_qualifier(s?)
    {
        my %qualifiers  = map { %$_ } @{ $item{'field_qualifier(s?)'} || [] };
        my $nullable = defined $qualifiers{'nullable'}
                   ? $qualifiers{'nullable'} : 1;
        $return = {
            supertype      => 'field',
            name           => $item{'field_name'},
            data_type      => $item{'data_type'}{'type'},
            size           => $item{'data_type'}{'size'},
            nullable       => $nullable,
            default        => $qualifiers{'default_val'},
            is_auto_inc    => $qualifiers{'is_auto_inc'},
#            is_primary_key => $item{'primary_key'}[0],
        }
    }

field_qualifier : nullable
    {
        $return = {
             nullable => $item{'nullable'},
        }
    }

field_qualifier : default_val
    {
        $return = {
             default_val => $item{'default_val'},
        }
    }

field_qualifier : auto_inc
    {
        $return = {
             is_auto_inc => $item{'auto_inc'},
        }
    }

constraint : primary_key_constraint
    | foreign_key_constraint
    | unique_constraint

field_name : WORD
   { $return = $item[1] }
   | LQUOTE WORD RQUOTE
   { $return = $item[2] }

index_name : WORD
   { $return = $item[1] }
   | LQUOTE WORD RQUOTE
   { $return = $item[2] }

table_name : WORD
 { $return = $item[1] }
 | LQUOTE WORD RQUOTE
 { $return = $item[2] }

data_type : WORD field_size(?)
    {
        $return = {
            type => $item[1],
            size => $item[2][0]
        }
    }

lock : /lock/i /datarows/i

field_type : WORD

field_size : '(' num_range ')' { $item{'num_range'} }

num_range : DIGITS ',' DIGITS
    { $return = $item[1].','.$item[3] }
               | DIGITS
    { $return = $item[1] }


nullable : /not/i /null/i
    { $return = 0 }
    | /null/i
    { $return = 1 }

default_val : /default/i /null/i
    { $return = 'null' }
   | /default/i /'[^']*'/
    { $item[2]=~ s/'//g; $return = $item[2] }
   | /default/i WORD
    { $return = $item[2] }

auto_inc : /identity/i { 1 }

primary_key_constraint : /constraint/i index_name(?) /primary/i /key/i parens_field_list
    {
        $return = {
            supertype => 'constraint',
            name      => $item[2][0],
            type      => 'primary_key',
            fields    => $item[5],
        }
    }

foreign_key_constraint : /constraint/i index_name(?) /foreign/i /key/i parens_field_list /references/i table_name parens_field_list(?) on_delete(?) on_update(?)
    {
        $return = {
            supertype        => 'constraint',
            name             => $item[2][0],
            type             => 'foreign_key',
            fields           => $item[5],
            reference_table  => $item[7],
            reference_fields => $item[8][0],
            on_delete        => $item[9][0],
            on_update        => $item[10][0],
        }
    }

unique_constraint : /constraint/i index_name(?) /unique/i parens_field_list
    {
        $return = {
            supertype => 'constraint',
            type      => 'unique',
            name      => $item[2][0],
            fields    => $item[4],
        }
    }

unique_constraint : /unique/i clustered(?) INDEX(?) index_name(?) on_table(?) parens_field_list field_not_null(?)
    {
        $return = {
            supertype => 'constraint',
            type      => 'unique',
            clustered => $item[2][0],
            name      => $item[4][0],
            table     => $item[5][0],
            fields    => $item[6],
        }
    }

on_delete : /on delete/i reference_option
    { $item[2] }

on_update : /on update/i reference_option
    { $item[2] }

reference_option: /cascade/i
    { $item[1] }
    | /no action/i
    { $item[1] }

clustered : /clustered/i
    { $return = 1 }
    | /nonclustered/i
    { $return = 0 }

INDEX : /index/i

on_table : /on/i table_name
    { $return = $item[2] }

on_system : /on/i /system/i
    { $return = 1 }

index : clustered(?) INDEX index_name(?) on_table(?) parens_field_list END_STATEMENT
    {
        $return = {
            supertype => 'index',
            type      => 'normal',
            clustered => $item[1][0],
            name      => $item[3][0],
            table     => $item[4][0],
            fields    => $item[5],
        }
    }

parens_field_list : '(' field_name(s /,/) ')'
    { $item[2] }

ident : QUOTE WORD '.' WORD QUOTE | LQUOTE WORD '.' WORD RQUOTE
    { $return = { owner => $item[2], name => $item[4] } }
    | LQUOTE WORD RQUOTE '.' LQUOTE WORD RQUOTE
    { $return = { owner => $item[2], name => $item[6] } }
    | LQUOTE WORD RQUOTE
    { $return = { name  => $item[2] } }
    | WORD '.' WORD
    { $return = { owner => $item[1], name => $item[3] } }
    | WORD
    { $return = { name  => $item[1] } }

END_STATEMENT : ';'
   | GO

GO : /^go/i

NAME : QUOTE(?) /\w+/ QUOTE(?)
    { $item[2] }

WORD : /[\w#]+/

DIGITS : /\d+/

COMMA : ','

QUOTE : /'/

LQUOTE : '['

RQUOTE : ']'

};

# -------------------------------------------------------------------
sub parse {
    my ( $translator, $data ) = @_;
    my $parser = Parse::RecDescent->new($GRAMMAR);

    local $::RD_TRACE  = $translator->trace ? 1 : undef;
    local $DEBUG       = $translator->debug;

    unless (defined $parser) {
        return $translator->error("Error instantiating Parse::RecDescent ".
            "instance: Bad grammer");
    }

    my $result = $parser->startrule($data);
    return $translator->error( "Parse failed." ) unless defined $result;
    warn Dumper( $result ) if $DEBUG;

    my $schema = $translator->schema;
    my @tables = sort {
        $result->{tables}->{ $a }->{'order'} <=> $result->{tables}->{ $b }->{'order'}
    } keys %{ $result->{tables} };

    for my $table_name ( @tables ) {
        my $tdata = $result->{tables}->{ $table_name };
        my $table = $schema->add_table( name => $tdata->{'name'} )
                    or die "Can't create table '$table_name': ", $schema->error;

        $table->comments( $tdata->{'comments'} );

        my @fields = sort {
            $tdata->{'fields'}->{$a}->{'order'}
            <=>
            $tdata->{'fields'}->{$b}->{'order'}
        } keys %{ $tdata->{'fields'} };

        for my $fname ( @fields ) {
            my $fdata = $tdata->{'fields'}{ $fname };
            my $field = $table->add_field(
                name              => $fdata->{'name'},
                data_type         => $fdata->{'data_type'},
                size              => $fdata->{'size'},
                default_value     => $fdata->{'default'},
                is_auto_increment => $fdata->{'is_auto_inc'},
                is_nullable       => $fdata->{'nullable'},
                comments          => $fdata->{'comments'},
            ) or die $table->error;

            $table->primary_key( $field->name ) if $fdata->{'is_primary_key'};

            for my $qual ( qw[ binary unsigned zerofill list ] ) {
                if ( my $val = $fdata->{ $qual } || $fdata->{ uc $qual } ) {
                    next if ref $val eq 'ARRAY' && !@$val;
                    $field->extra( $qual, $val );
                }
            }

            if ( $field->data_type =~ /(set|enum)/i && !$field->size ) {
                my %extra = $field->extra;
                my $longest = 0;
                for my $len ( map { length } @{ $extra{'list'} || [] } ) {
                    $longest = $len if $len > $longest;
                }
                $field->size( $longest ) if $longest;
            }

            for my $cdata ( @{ $fdata->{'constraints'} } ) {
                next unless $cdata->{'type'} eq 'foreign_key';
                $cdata->{'fields'} ||= [ $field->name ];
                push @{ $tdata->{'constraints'} }, $cdata;
            }
        }

        for my $idata ( @{ $tdata->{'indices'} || [] } ) {
            my $index  =  $table->add_index(
                name   => $idata->{'name'},
                type   => uc $idata->{'type'},
                fields => $idata->{'fields'},
            ) or die $table->error;
        }

        for my $cdata ( @{ $tdata->{'constraints'} || [] } ) {
            my $constraint       =  $table->add_constraint(
                name             => $cdata->{'name'},
                type             => $cdata->{'type'},
                fields           => $cdata->{'fields'},
                reference_table  => $cdata->{'reference_table'},
                reference_fields => $cdata->{'reference_fields'},
                match_type       => $cdata->{'match_type'} || '',
                on_delete        => $cdata->{'on_delete'} || $cdata->{'on_delete_do'},
                on_update        => $cdata->{'on_update'} || $cdata->{'on_update_do'},
            ) or die $table->error;
        }
    }

    my @procedures = sort {
        $result->{procedures}->{ $a }->{'order'} <=> $result->{procedures}->{ $b }->{'order'}
    } keys %{ $result->{procedures} };
    for my $proc_name (@procedures) {
      $schema->add_procedure(
         name  => $proc_name,
         owner => $result->{procedures}->{$proc_name}->{owner},
         sql   => $result->{procedures}->{$proc_name}->{sql},
      );
    }

    my @views = sort {
        $result->{views}->{ $a }->{'order'} <=> $result->{views}->{ $b }->{'order'}
    } keys %{ $result->{views} };
    for my $view_name (keys %{ $result->{views} }) {
      $schema->add_view(
         name => $view_name,
         sql  => $result->{views}->{$view_name}->{sql},
      );
    }

    return 1;
}

1;

# -------------------------------------------------------------------
# Every hero becomes a bore at last.
# Ralph Waldo Emerson
# -------------------------------------------------------------------

=pod

=head1 AUTHOR

Chris Hilton E<lt>chris@dctank.comE<gt> - Bulk of code from
Sybase parser, I just tweaked it for SQLServer. Thanks.

=head1 SEE ALSO

SQL::Translator, SQL::Translator::Parser::DBI, L<http://www.midsomer.org/>.

=cut
Commit	Line	Data
be4469ab	1	package SQL::Translator::Parser::SQLServer;
be4469ab	2
44659089	3	# -------------------------------------------------------------------
	4	# Copyright (C) 2002-2009 SQLFairy Authors
	5	#
	6	# This program is free software; you can redistribute it and/or
	7	# modify it under the terms of the GNU General Public License as
	8	# published by the Free Software Foundation; version 2.
	9	#
	10	# This program is distributed in the hope that it will be useful, but
	11	# WITHOUT ANY WARRANTY; without even the implied warranty of
	12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	# General Public License for more details.
	14	#
	15	# You should have received a copy of the GNU General Public License
	16	# along with this program; if not, write to the Free Software
	17	# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
	18	# 02111-1307 USA
	19	# -------------------------------------------------------------------
	20
be4469ab	21	=head1 NAME
	22
	23	SQL::Translator::Parser::SQLServer - parser for SQL Server
	24
	25	=head1 SYNOPSIS
	26
	27	use SQL::Translator::Parser::SQLServer;
	28
	29	=head1 DESCRIPTION
	30
	31	Adapted from Parser::Sybase and mostly parses the output of
	32	Producer::SQLServer. The parsing is by no means complete and
	33	should probably be considered a work in progress.
	34
	35	=cut
	36
	37	use strict;
	38
da06ac74	39	use vars qw[ $DEBUG $VERSION $GRAMMAR @EXPORT_OK ];
11ad2df9	40	$VERSION = '1.59';
be4469ab	41	$DEBUG = 0 unless defined $DEBUG;
	42
	43	use Data::Dumper;
	44	use Parse::RecDescent;
	45	use Exporter;
	46	use base qw(Exporter);
	47
	48	@EXPORT_OK = qw(parse);
	49
	50	$::RD_ERRORS = 1;
	51	$::RD_WARN = 1;
	52	$::RD_HINT = 1;
	53
	54	$GRAMMAR = q{
	55
e5f65c59	56	{
ff3dd529	57	my ( %tables, @table_comments, $table_order, %procedures, $proc_order, %views, $view_order );
28224573	58
	59	sub _err {
	60	my $max_lines = 5;
	61	my @up_to_N_lines = split (/\n/, $_[1], $max_lines + 1);
	62	die sprintf ("Unable to parse line %d:\n%s\n",
	63	$_[0],
	64	join "\n", (map { "'$_'" } @up_to_N_lines[0..$max_lines - 1 ]), @up_to_N_lines > $max_lines ? '...' : ()
	65	);
	66	}
	67
be4469ab	68	}
be4469ab	69
ff3dd529	70	startrule : statement(s) eofile
e5f65c59	71	{
	72	return {
	73	tables => \%tables,
	74	procedures => \%procedures,
	75	views => \%views,
	76	}
	77	}
be4469ab	78
	79	eofile : /^\Z/
	80
	81	statement : create_table
	82	\| create_procedure
ff3dd529	83	\| create_view
be4469ab	84	\| create_index
	85	\| create_constraint
	86	\| comment
028386aa	87	\| disable_constraints
e2fb9ad3	88	\| drop
be4469ab	89	\| use
	90	\| setuser
	91	\| if
	92	\| print
	93	\| grant
	94	\| exec
28224573	95	\| /^\Z/ \| { _err ($thisline, $text) }
be4469ab	96
e5f65c59	97	use : /use/i WORD GO
be4469ab	98	{ @table_comments = () }
	99
	100	setuser : /setuser/i NAME GO
	101
	102	if : /if/i object_not_null begin if_command end GO
	103
	104	if_command : grant
	105	\| create_index
	106	\| create_constraint
	107
	108	object_not_null : /object_id/i '(' ident ')' /is not null/i
	109
028386aa	110	field_not_null : /where/i field_name /is \s+ not \s+ null/ix
028386aa	111
be4469ab	112	print : /\s/ /print/i /./
	113
	114	else : /else/i /.*/
	115
	116	begin : /begin/i
	117
	118	end : /end/i
	119
	120	grant : /grant/i /[^\n]*/
	121
	122	exec : exec_statement(s) GO
	123
	124	exec_statement : /exec/i /[^\n]+/
	125
e5f65c59	126	comment : /^\s(?:#\|-{2}).\n/
e5f65c59	127	{
be4469ab	128	my $comment = $item[1];
	129	$comment =~ s/^\s(#\|--)\s//;
	130	$comment =~ s/\s*$//;
	131	$return = $comment;
	132	push @table_comments, $comment;
	133	}
	134
	135	comment : comment_start comment_middle comment_end
e5f65c59	136	{
be4469ab	137	my $comment = $item[2];
	138	$comment =~ s/^\s\|\s$//mg;
	139	$comment =~ s/^\*\s//mg;
	140	push @table_comments, $comment;
	141	}
	142
	143	comment_start : m#^\s\/\#
	144
	145	comment_end : m#\s\\/#
	146
	147	comment_middle : m{([^]+\|\(?!/))*}
	148
e2fb9ad3	149	drop : if_exists(?) /drop/i tbl_drop END_STATEMENT
e2fb9ad3	150
028386aa	151	tbl_drop : /table/i ident
e2fb9ad3	152
	153	if_exists : /if exists/i '(' /select/i 'name' /from/i 'sysobjects' /[^\)]+/ ')'
	154
be4469ab	155	#
	156	# Create table.
	157	#
ff3dd529	158	create_table : /create/i /table/i ident '(' create_def(s /,/) ')' lock(?) on_system(?) END_STATEMENT
e5f65c59	159	{
be4469ab	160	my $table_owner = $item[3]{'owner'};
	161	my $table_name = $item[3]{'name'};
	162
	163	if ( @table_comments ) {
	164	$tables{ $table_name }{'comments'} = [ @table_comments ];
	165	@table_comments = ();
	166	}
	167
	168	$tables{ $table_name }{'order'} = ++$table_order;
	169	$tables{ $table_name }{'name'} = $table_name;
	170	$tables{ $table_name }{'owner'} = $table_owner;
	171	$tables{ $table_name }{'system'} = $item[7];
	172
	173	my $i = 0;
	174	for my $def ( @{ $item[5] } ) {
	175	if ( $def->{'supertype'} eq 'field' ) {
	176	my $field_name = $def->{'name'};
e5f65c59	177	$tables{ $table_name }{'fields'}{ $field_name } =
be4469ab	178	{ %$def, order => $i };
be4469ab	179	$i++;
e5f65c59	180
be4469ab	181	if ( $def->{'is_primary_key'} ) {
	182	push @{ $tables{ $table_name }{'constraints'} }, {
	183	type => 'primary_key',
	184	fields => [ $field_name ],
	185	};
	186	}
	187	}
	188	elsif ( $def->{'supertype'} eq 'constraint' ) {
	189	push @{ $tables{ $table_name }{'constraints'} }, $def;
	190	}
	191	else {
	192	push @{ $tables{ $table_name }{'indices'} }, $def;
	193	}
	194	}
	195	}
	196
028386aa	197	disable_constraints : if_exists(?) /alter/i /table/i ident /nocheck/i /constraint/i /all/i END_STATEMENT
	198
	199	# this is for the normal case
	200	create_constraint : /create/i constraint END_STATEMENT
	201	{
	202	@table_comments = ();
	203	push @{ $tables{ $item[2]{'table'} }{'constraints'} }, $item[2];
	204	}
	205
	206	# and this is for the BEGIN/END case
f9a5ee79	207	create_constraint : /create/i constraint
be4469ab	208	{
	209	@table_comments = ();
	210	push @{ $tables{ $item[2]{'table'} }{'constraints'} }, $item[2];
	211	}
	212
028386aa	213
f9a5ee79	214	create_constraint : /alter/i /table/i ident /add/i foreign_key_constraint END_STATEMENT
	215	{
	216	push @{ $tables{ $item[3]{name} }{constraints} }, $item[5];
	217	}
	218
028386aa	219
be4469ab	220	create_index : /create/i index
	221	{
	222	@table_comments = ();
	223	push @{ $tables{ $item[2]{'table'} }{'indices'} }, $item[2];
	224	}
	225
ff3dd529	226	create_procedure : /create/i PROCEDURE WORD not_go GO
be4469ab	227	{
be4469ab	228	@table_comments = ();
ff3dd529	229	my $proc_name = $item[3];
	230	my $owner = '';
	231	my $sql = "$item[1] $item[2] $proc_name $item[4]";
e5f65c59	232
ff3dd529	233	$procedures{ $proc_name }{'order'} = ++$proc_order;
	234	$procedures{ $proc_name }{'name'} = $proc_name;
	235	$procedures{ $proc_name }{'owner'} = $owner;
	236	$procedures{ $proc_name }{'sql'} = $sql;
be4469ab	237	}
be4469ab	238
ff3dd529	239	create_procedure : /create/i PROCEDURE '[' WORD '].' WORD not_go GO
	240	{
	241	@table_comments = ();
	242	my $proc_name = $item[6];
	243	my $owner = $item[4];
	244	my $sql = "$item[1] $item[2] [$owner].$proc_name $item[7]";
e5f65c59	245
ff3dd529	246	$procedures{ $proc_name }{'order'} = ++$proc_order;
	247	$procedures{ $proc_name }{'name'} = $proc_name;
	248	$procedures{ $proc_name }{'owner'} = $owner;
	249	$procedures{ $proc_name }{'sql'} = $sql;
	250	}
	251
	252	PROCEDURE : /procedure/i
e5f65c59	253	\| /function/i
ff3dd529	254
ff3dd529	255	create_view : /create/i /view/i WORD not_go GO
	256	{
	257	@table_comments = ();
	258	my $view_name = $item[3];
	259	my $sql = "$item[1] $item[2] $item[3] $item[4]";
e5f65c59	260
ff3dd529	261	$views{ $view_name }{'order'} = ++$view_order;
	262	$views{ $view_name }{'name'} = $view_name;
	263	$views{ $view_name }{'sql'} = $sql;
	264	}
	265
ff3dd529	266	not_go : /((?!\bgo\b).)*/is
be4469ab	267
	268	create_def : constraint
	269	\| index
	270	\| field
	271
	272	blank : /\s*/
	273
	274	field : field_name data_type field_qualifier(s?)
e5f65c59	275	{
be4469ab	276	my %qualifiers = map { %$_ } @{ $item{'field_qualifier(s?)'} \|\| [] };
e5f65c59	277	my $nullable = defined $qualifiers{'nullable'}
be4469ab	278	? $qualifiers{'nullable'} : 1;
e5f65c59	279	$return = {
be4469ab	280	supertype => 'field',
e5f65c59	281	name => $item{'field_name'},
be4469ab	282	data_type => $item{'data_type'}{'type'},
be4469ab	283	size => $item{'data_type'}{'size'},
e5f65c59	284	nullable => $nullable,
	285	default => $qualifiers{'default_val'},
	286	is_auto_inc => $qualifiers{'is_auto_inc'},
	287	# is_primary_key => $item{'primary_key'}[0],
	288	}
be4469ab	289	}
	290
	291	field_qualifier : nullable
e5f65c59	292	{
e5f65c59	293	$return = {
be4469ab	294	nullable => $item{'nullable'},
e5f65c59	295	}
be4469ab	296	}
	297
	298	field_qualifier : default_val
e5f65c59	299	{
e5f65c59	300	$return = {
be4469ab	301	default_val => $item{'default_val'},
e5f65c59	302	}
be4469ab	303	}
	304
	305	field_qualifier : auto_inc
e5f65c59	306	{
e5f65c59	307	$return = {
be4469ab	308	is_auto_inc => $item{'auto_inc'},
e5f65c59	309	}
be4469ab	310	}
	311
	312	constraint : primary_key_constraint
	313	\| foreign_key_constraint
	314	\| unique_constraint
	315
	316	field_name : WORD
028386aa	317	{ $return = $item[1] }
	318	\| LQUOTE WORD RQUOTE
	319	{ $return = $item[2] }
be4469ab	320
be4469ab	321	index_name : WORD
028386aa	322	{ $return = $item[1] }
	323	\| LQUOTE WORD RQUOTE
	324	{ $return = $item[2] }
be4469ab	325
be4469ab	326	table_name : WORD
028386aa	327	{ $return = $item[1] }
	328	\| LQUOTE WORD RQUOTE
	329	{ $return = $item[2] }
be4469ab	330
e5f65c59	331	data_type : WORD field_size(?)
	332	{
	333	$return = {
	334	type => $item[1],
be4469ab	335	size => $item[2][0]
e5f65c59	336	}
be4469ab	337	}
	338
	339	lock : /lock/i /datarows/i
	340
	341	field_type : WORD
	342
	343	field_size : '(' num_range ')' { $item{'num_range'} }
	344
	345	num_range : DIGITS ',' DIGITS
	346	{ $return = $item[1].','.$item[3] }
	347	\| DIGITS
	348	{ $return = $item[1] }
	349
	350
	351	nullable : /not/i /null/i
	352	{ $return = 0 }
	353	\| /null/i
	354	{ $return = 1 }
	355
2a8fb466	356	default_val : /default/i /null/i
2a8fb466	357	{ $return = 'null' }
e5f65c59	358	\| /default/i /'[^']*'/
be4469ab	359	{ $item[2]=~ s/'//g; $return = $item[2] }
e5f65c59	360	\| /default/i WORD
06baeb21	361	{ $return = $item[2] }
be4469ab	362
	363	auto_inc : /identity/i { 1 }
	364
	365	primary_key_constraint : /constraint/i index_name(?) /primary/i /key/i parens_field_list
e5f65c59	366	{
e5f65c59	367	$return = {
be4469ab	368	supertype => 'constraint',
	369	name => $item[2][0],
	370	type => 'primary_key',
	371	fields => $item[5],
e5f65c59	372	}
be4469ab	373	}
be4469ab	374
100684f3	375	foreign_key_constraint : /constraint/i index_name(?) /foreign/i /key/i parens_field_list /references/i table_name parens_field_list(?) on_delete(?) on_update(?)
be4469ab	376	{
e5f65c59	377	$return = {
be4469ab	378	supertype => 'constraint',
	379	name => $item[2][0],
	380	type => 'foreign_key',
	381	fields => $item[5],
	382	reference_table => $item[7],
e5f65c59	383	reference_fields => $item[8][0],
100684f3	384	on_delete => $item[9][0],
100684f3	385	on_update => $item[10][0],
e5f65c59	386	}
be4469ab	387	}
be4469ab	388
e2fb9ad3	389	unique_constraint : /constraint/i index_name(?) /unique/i parens_field_list
e2fb9ad3	390	{
e5f65c59	391	$return = {
e2fb9ad3	392	supertype => 'constraint',
	393	type => 'unique',
	394	name => $item[2][0],
	395	fields => $item[4],
	396	}
	397	}
	398
028386aa	399	unique_constraint : /unique/i clustered(?) INDEX(?) index_name(?) on_table(?) parens_field_list field_not_null(?)
e5f65c59	400	{
e5f65c59	401	$return = {
be4469ab	402	supertype => 'constraint',
	403	type => 'unique',
	404	clustered => $item[2][0],
	405	name => $item[4][0],
	406	table => $item[5][0],
	407	fields => $item[6],
e5f65c59	408	}
be4469ab	409	}
be4469ab	410
100684f3	411	on_delete : /on delete/i reference_option
be4469ab	412	{ $item[2] }
be4469ab	413
100684f3	414	on_update : /on update/i reference_option
be4469ab	415	{ $item[2] }
be4469ab	416
ff3dd529	417	reference_option: /cascade/i
	418	{ $item[1] }
	419	\| /no action/i
	420	{ $item[1] }
be4469ab	421
	422	clustered : /clustered/i
	423	{ $return = 1 }
	424	\| /nonclustered/i
	425	{ $return = 0 }
	426
	427	INDEX : /index/i
	428
	429	on_table : /on/i table_name
	430	{ $return = $item[2] }
	431
	432	on_system : /on/i /system/i
	433	{ $return = 1 }
	434
e2fb9ad3	435	index : clustered(?) INDEX index_name(?) on_table(?) parens_field_list END_STATEMENT
e5f65c59	436	{
e5f65c59	437	$return = {
be4469ab	438	supertype => 'index',
	439	type => 'normal',
	440	clustered => $item[1][0],
	441	name => $item[3][0],
	442	table => $item[4][0],
	443	fields => $item[5],
e5f65c59	444	}
be4469ab	445	}
	446
	447	parens_field_list : '(' field_name(s /,/) ')'
	448	{ $item[2] }
	449
028386aa	450	ident : QUOTE WORD '.' WORD QUOTE \| LQUOTE WORD '.' WORD RQUOTE
be4469ab	451	{ $return = { owner => $item[2], name => $item[4] } }
028386aa	452	\| LQUOTE WORD RQUOTE '.' LQUOTE WORD RQUOTE
	453	{ $return = { owner => $item[2], name => $item[6] } }
	454	\| LQUOTE WORD RQUOTE
	455	{ $return = { name => $item[2] } }
	456	\| WORD '.' WORD
	457	{ $return = { owner => $item[1], name => $item[3] } }
be4469ab	458	\| WORD
	459	{ $return = { name => $item[1] } }
	460
ff3dd529	461	END_STATEMENT : ';'
e5f65c59	462	\| GO
ff3dd529	463
be4469ab	464	GO : /^go/i
	465
	466	NAME : QUOTE(?) /\w+/ QUOTE(?)
	467	{ $item[2] }
	468
	469	WORD : /[\w#]+/
	470
	471	DIGITS : /\d+/
	472
	473	COMMA : ','
	474
	475	QUOTE : /'/
	476
028386aa	477	LQUOTE : '['
	478
	479	RQUOTE : ']'
	480
be4469ab	481	};
	482
	483	# -------------------------------------------------------------------
	484	sub parse {
	485	my ( $translator, $data ) = @_;
	486	my $parser = Parse::RecDescent->new($GRAMMAR);
	487
	488	local $::RD_TRACE = $translator->trace ? 1 : undef;
	489	local $DEBUG = $translator->debug;
	490
	491	unless (defined $parser) {
	492	return $translator->error("Error instantiating Parse::RecDescent ".
	493	"instance: Bad grammer");
	494	}
	495
	496	my $result = $parser->startrule($data);
	497	return $translator->error( "Parse failed." ) unless defined $result;
	498	warn Dumper( $result ) if $DEBUG;
	499
	500	my $schema = $translator->schema;
e5f65c59	501	my @tables = sort {
ff3dd529	502	$result->{tables}->{ $a }->{'order'} <=> $result->{tables}->{ $b }->{'order'}
ff3dd529	503	} keys %{ $result->{tables} };
be4469ab	504
be4469ab	505	for my $table_name ( @tables ) {
ff3dd529	506	my $tdata = $result->{tables}->{ $table_name };
e5f65c59	507	my $table = $schema->add_table( name => $tdata->{'name'} )
be4469ab	508	or die "Can't create table '$table_name': ", $schema->error;
	509
	510	$table->comments( $tdata->{'comments'} );
	511
e5f65c59	512	my @fields = sort {
e5f65c59	513	$tdata->{'fields'}->{$a}->{'order'}
be4469ab	514	<=>
	515	$tdata->{'fields'}->{$b}->{'order'}
	516	} keys %{ $tdata->{'fields'} };
	517
	518	for my $fname ( @fields ) {
	519	my $fdata = $tdata->{'fields'}{ $fname };
	520	my $field = $table->add_field(
	521	name => $fdata->{'name'},
	522	data_type => $fdata->{'data_type'},
	523	size => $fdata->{'size'},
	524	default_value => $fdata->{'default'},
	525	is_auto_increment => $fdata->{'is_auto_inc'},
	526	is_nullable => $fdata->{'nullable'},
	527	comments => $fdata->{'comments'},
	528	) or die $table->error;
	529
	530	$table->primary_key( $field->name ) if $fdata->{'is_primary_key'};
	531
	532	for my $qual ( qw[ binary unsigned zerofill list ] ) {
	533	if ( my $val = $fdata->{ $qual } \|\| $fdata->{ uc $qual } ) {
	534	next if ref $val eq 'ARRAY' && !@$val;
	535	$field->extra( $qual, $val );
	536	}
	537	}
	538
	539	if ( $field->data_type =~ /(set\|enum)/i && !$field->size ) {
	540	my %extra = $field->extra;
	541	my $longest = 0;
	542	for my $len ( map { length } @{ $extra{'list'} \|\| [] } ) {
	543	$longest = $len if $len > $longest;
	544	}
	545	$field->size( $longest ) if $longest;
	546	}
	547
	548	for my $cdata ( @{ $fdata->{'constraints'} } ) {
	549	next unless $cdata->{'type'} eq 'foreign_key';
	550	$cdata->{'fields'} \|\|= [ $field->name ];
	551	push @{ $tdata->{'constraints'} }, $cdata;
	552	}
	553	}
	554
	555	for my $idata ( @{ $tdata->{'indices'} \|\| [] } ) {
	556	my $index = $table->add_index(
	557	name => $idata->{'name'},
	558	type => uc $idata->{'type'},
	559	fields => $idata->{'fields'},
	560	) or die $table->error;
	561	}
	562
	563	for my $cdata ( @{ $tdata->{'constraints'} \|\| [] } ) {
	564	my $constraint = $table->add_constraint(
	565	name => $cdata->{'name'},
	566	type => $cdata->{'type'},
	567	fields => $cdata->{'fields'},
	568	reference_table => $cdata->{'reference_table'},
	569	reference_fields => $cdata->{'reference_fields'},
	570	match_type => $cdata->{'match_type'} \|\| '',
100684f3	571	on_delete => $cdata->{'on_delete'} \|\| $cdata->{'on_delete_do'},
100684f3	572	on_update => $cdata->{'on_update'} \|\| $cdata->{'on_update_do'},
be4469ab	573	) or die $table->error;
	574	}
	575	}
e5f65c59	576
e5f65c59	577	my @procedures = sort {
ff3dd529	578	$result->{procedures}->{ $a }->{'order'} <=> $result->{procedures}->{ $b }->{'order'}
	579	} keys %{ $result->{procedures} };
	580	for my $proc_name (@procedures) {
e5f65c59	581	$schema->add_procedure(
	582	name => $proc_name,
	583	owner => $result->{procedures}->{$proc_name}->{owner},
	584	sql => $result->{procedures}->{$proc_name}->{sql},
	585	);
ff3dd529	586	}
ff3dd529	587
e5f65c59	588	my @views = sort {
ff3dd529	589	$result->{views}->{ $a }->{'order'} <=> $result->{views}->{ $b }->{'order'}
	590	} keys %{ $result->{views} };
	591	for my $view_name (keys %{ $result->{views} }) {
e5f65c59	592	$schema->add_view(
	593	name => $view_name,
	594	sql => $result->{views}->{$view_name}->{sql},
	595	);
ff3dd529	596	}
be4469ab	597
	598	return 1;
	599	}
	600
	601	1;
	602
	603	# -------------------------------------------------------------------
	604	# Every hero becomes a bore at last.
	605	# Ralph Waldo Emerson
	606	# -------------------------------------------------------------------
	607
	608	=pod
	609
	610	=head1 AUTHOR
	611
	612	Chris Hilton E<lt>chris@dctank.comE<gt> - Bulk of code from
	613	Sybase parser, I just tweaked it for SQLServer. Thanks.
	614
	615	=head1 SEE ALSO
	616
	617	SQL::Translator, SQL::Translator::Parser::DBI, L<http://www.midsomer.org/>.
	618
	619	=cut