From: Justin Hunter Date: Fri, 31 Jul 2009 02:56:44 +0000 (-0700) Subject: inital SQLite grammar X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=5ea690346f4bdf1897109a839482fbcae0c86ad6;p=dbsrgits%2FSQL-Translator-2.0-ish.git inital SQLite grammar --- diff --git a/lib/SQL/Translator/Grammar/SQLite.pm b/lib/SQL/Translator/Grammar/SQLite.pm new file mode 100644 index 0000000..187e1ab --- /dev/null +++ b/lib/SQL/Translator/Grammar/SQLite.pm @@ -0,0 +1,17594 @@ +package SQL::Translator::Grammar::SQLite; +# ------------------------------------------------------------------- +# 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::Grammar::SQLite - grammar for SQLite + +=head1 DESCRIPTION + +This is a grammar for parsing CREATE statements for SQLite as +described here: + + http://www.sqlite.org/lang.html + +CREATE INDEX + +sql-statement ::= + CREATE [TEMP | TEMPORARY] [UNIQUE] INDEX index-name + ON [database-name .] table-name ( column-name [, column-name]* ) + [ ON CONFLICT conflict-algorithm ] + +column-name ::= + name [ ASC | DESC ] + +CREATE TABLE + +sql-command ::= + CREATE [TEMP | TEMPORARY] TABLE table-name ( + column-def [, column-def]* + [, constraint]* + ) + +sql-command ::= + CREATE [TEMP | TEMPORARY] TABLE table-name AS select-statement + +column-def ::= + name [type] [[CONSTRAINT name] column-constraint]* + +type ::= + typename | + typename ( number ) | + typename ( number , number ) + +column-constraint ::= + NOT NULL [ conflict-clause ] | + PRIMARY KEY [sort-order] [ conflict-clause ] | + UNIQUE [ conflict-clause ] | + CHECK ( expr ) [ conflict-clause ] | + DEFAULT value + +constraint ::= + PRIMARY KEY ( name [, name]* ) [ conflict-clause ]| + UNIQUE ( name [, name]* ) [ conflict-clause ] | + CHECK ( expr ) [ conflict-clause ] + +conflict-clause ::= + ON CONFLICT conflict-algorithm + +CREATE TRIGGER + +sql-statement ::= + CREATE [TEMP | TEMPORARY] TRIGGER trigger-name [ BEFORE | AFTER ] + database-event ON [database-name .] table-name + trigger-action + +sql-statement ::= + CREATE [TEMP | TEMPORARY] TRIGGER trigger-name INSTEAD OF + database-event ON [database-name .] view-name + trigger-action + +database-event ::= + DELETE | + INSERT | + UPDATE | + UPDATE OF column-list + +trigger-action ::= + [ FOR EACH ROW | FOR EACH STATEMENT ] [ WHEN expression ] + BEGIN + trigger-step ; [ trigger-step ; ]* + END + +trigger-step ::= + update-statement | insert-statement | + delete-statement | select-statement + +CREATE VIEW + +sql-command ::= + CREATE [TEMP | TEMPORARY] VIEW view-name AS select-statement + +ON CONFLICT clause + + conflict-clause ::= + ON CONFLICT conflict-algorithm + + conflict-algorithm ::= + ROLLBACK | ABORT | FAIL | IGNORE | REPLACE + +expression + +expr ::= + expr binary-op expr | + expr like-op expr | + unary-op expr | + ( expr ) | + column-name | + table-name . column-name | + database-name . table-name . column-name | + literal-value | + function-name ( expr-list | * ) | + expr (+) | + expr ISNULL | + expr NOTNULL | + expr [NOT] BETWEEN expr AND expr | + expr [NOT] IN ( value-list ) | + expr [NOT] IN ( select-statement ) | + ( select-statement ) | + CASE [expr] ( WHEN expr THEN expr )+ [ELSE expr] END + +like-op::= + LIKE | GLOB | NOT LIKE | NOT GLOB + +=cut + +use Parse::RecDescent; + +{ my $ERRORS; + + +package Parse::RecDescent::SQL::Translator::Grammar::SQLite; +use strict; +use vars qw($skip $AUTOLOAD ); +$skip = '\s*'; + + my ( %tables, $table_order, @table_comments, @views, @triggers ); +; + + +{ +local $SIG{__WARN__} = sub {0}; +# PRETEND TO BE IN Parse::RecDescent NAMESPACE +*Parse::RecDescent::SQL::Translator::Grammar::SQLite::AUTOLOAD = sub +{ + no strict 'refs'; + $AUTOLOAD =~ s/^Parse::RecDescent::SQL::Translator::Grammar::SQLite/Parse::RecDescent/; + goto &{$AUTOLOAD}; +} +} + +push @Parse::RecDescent::SQL::Translator::Grammar::SQLite::ISA, 'Parse::RecDescent'; +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::WORD +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"WORD"}; + + Parse::RecDescent::_trace(q{Trying rule: [WORD]}, + Parse::RecDescent::_tracefirst($_[1]), + q{WORD}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/\\w+/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{WORD}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{WORD}); + %item = (__RULE__ => q{WORD}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/\\w+/]}, Parse::RecDescent::_tracefirst($text), + q{WORD}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\w+)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/\\w+/]<<}, + Parse::RecDescent::_tracefirst($text), + q{WORD}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{WORD}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{WORD}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{WORD}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{WORD}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::statement_body +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"statement_body"}; + + Parse::RecDescent::_trace(q{Trying rule: [statement_body]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [string]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{statement_body}); + %item = (__RULE__ => q{statement_body}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [string]}, + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::string($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [string]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{string}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [string]<<}, + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [nonstring]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{statement_body}); + %item = (__RULE__ => q{statement_body}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [nonstring]}, + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::nonstring($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [nonstring]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{nonstring}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [nonstring]<<}, + Parse::RecDescent::_tracefirst($text), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{statement_body}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{statement_body}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{statement_body}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::for_each +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"for_each"}; + + Parse::RecDescent::_trace(q{Trying rule: [for_each]}, + Parse::RecDescent::_tracefirst($_[1]), + q{for_each}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/FOR EACH ROW/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{for_each}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{for_each}); + %item = (__RULE__ => q{for_each}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/FOR EACH ROW/i]}, Parse::RecDescent::_tracefirst($text), + q{for_each}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:FOR EACH ROW)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/FOR EACH ROW/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{for_each}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{for_each}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{for_each}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{for_each}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{for_each}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::column_def +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"column_def"}; + + Parse::RecDescent::_trace(q{Trying rule: [column_def]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [comment NAME type column_constraint]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{column_def}); + %item = (__RULE__ => q{column_def}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [comment]}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::comment, 0, 100000000, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [comment]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{comment(s?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [NAME]}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{NAME})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::NAME($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [NAME]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{NAME}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [type]}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{type})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::type, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [type]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{type(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [column_constraint]}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{column_constraint})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::column_constraint, 0, 100000000, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [column_constraint]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{column_constraint(s?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + my $column = { + supertype => 'column', + name => $item[2], + data_type => $item[3][0]->{'type'}, + size => $item[3][0]->{'size'}, + is_nullable => 1, + is_primary_key => 0, + is_unique => 0, + check => '', + default => undef, + constraints => $item[4], + comments => $item[1], + }; + + + for my $c ( @{ $item[4] } ) { + if ( $c->{'type'} eq 'not_null' ) { + $column->{'is_nullable'} = 0; + } + elsif ( $c->{'type'} eq 'primary_key' ) { + $column->{'is_primary_key'} = 1; + } + elsif ( $c->{'type'} eq 'unique' ) { + $column->{'is_unique'} = 1; + } + elsif ( $c->{'type'} eq 'check' ) { + $column->{'check'} = $c->{'expression'}; + } + elsif ( $c->{'type'} eq 'default' ) { + $column->{'default'} = $c->{'value'}; + } + } + + $column; + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [comment NAME type column_constraint]<<}, + Parse::RecDescent::_tracefirst($text), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{column_def}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{column_def}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{column_def}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::constraint_def +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"constraint_def"}; + + Parse::RecDescent::_trace(q{Trying rule: [constraint_def]}, + Parse::RecDescent::_tracefirst($_[1]), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [PRIMARY_KEY parens_field_list conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{constraint_def}); + %item = (__RULE__ => q{constraint_def}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [PRIMARY_KEY]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::PRIMARY_KEY($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [PRIMARY_KEY]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{PRIMARY_KEY}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [parens_field_list]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{parens_field_list})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::parens_field_list($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [parens_field_list]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{parens_field_list}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + supertype => 'constraint', + type => 'primary_key', + columns => $item[2], + on_conflict => $item[3][0], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [PRIMARY_KEY parens_field_list conflict_clause]<<}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [UNIQUE parens_field_list conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{constraint_def}); + %item = (__RULE__ => q{constraint_def}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [UNIQUE]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::UNIQUE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [UNIQUE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{UNIQUE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [parens_field_list]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{parens_field_list})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::parens_field_list($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [parens_field_list]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{parens_field_list}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + supertype => 'constraint', + type => 'unique', + columns => $item[2], + on_conflict => $item[3][0], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [UNIQUE parens_field_list conflict_clause]<<}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [CHECK_C '(' expr ')' conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[2]; + $text = $_[1]; + my $_savetext; + @item = (q{constraint_def}); + %item = (__RULE__ => q{constraint_def}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [CHECK_C]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::CHECK_C($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [CHECK_C]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{CHECK_C}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying terminal: ['(']}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{'('})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\(//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [expr]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{expr})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{expr}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying terminal: [')']}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{')'})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING2__}=$&; + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + supertype => 'constraint', + type => 'check', + expression => $item[3], + on_conflict => $item[5][0], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [CHECK_C '(' expr ')' conflict_clause]<<}, + Parse::RecDescent::_tracefirst($text), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{constraint_def}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{constraint_def}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{constraint_def}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::string +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"string"}; + + Parse::RecDescent::_trace(q{Trying rule: [string]}, + Parse::RecDescent::_tracefirst($_[1]), + q{string}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/'(\\\\.|''|[^\\\\\\'])*'/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{string}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{string}); + %item = (__RULE__ => q{string}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/'(\\\\.|''|[^\\\\\\'])*'/]}, Parse::RecDescent::_tracefirst($text), + q{string}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:'(\\.|''|[^\\\'])*')//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/'(\\\\.|''|[^\\\\\\'])*'/]<<}, + Parse::RecDescent::_tracefirst($text), + q{string}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{string}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{string}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{string}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{string}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_algorigthm +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"conflict_algorigthm"}; + + Parse::RecDescent::_trace(q{Trying rule: [conflict_algorigthm]}, + Parse::RecDescent::_tracefirst($_[1]), + q{conflict_algorigthm}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/(rollback|abort|fail|ignore|replace)/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{conflict_algorigthm}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{conflict_algorigthm}); + %item = (__RULE__ => q{conflict_algorigthm}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/(rollback|abort|fail|ignore|replace)/i]}, Parse::RecDescent::_tracefirst($text), + q{conflict_algorigthm}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(rollback|abort|fail|ignore|replace))//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/(rollback|abort|fail|ignore|replace)/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{conflict_algorigthm}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{conflict_algorigthm}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{conflict_algorigthm}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{conflict_algorigthm}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{conflict_algorigthm}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::INDEX +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"INDEX"}; + + Parse::RecDescent::_trace(q{Trying rule: [INDEX]}, + Parse::RecDescent::_tracefirst($_[1]), + q{INDEX}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/index/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{INDEX}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{INDEX}); + %item = (__RULE__ => q{INDEX}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/index/i]}, Parse::RecDescent::_tracefirst($text), + q{INDEX}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:index)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/index/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{INDEX}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{INDEX}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{INDEX}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{INDEX}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{INDEX}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::view_drop +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"view_drop"}; + + Parse::RecDescent::_trace(q{Trying rule: [view_drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [VIEW if_exists view_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{view_drop}); + %item = (__RULE__ => q{view_drop}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [VIEW]}, + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::VIEW($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [VIEW]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{VIEW}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [if_exists]}, + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{if_exists})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::if_exists, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [if_exists]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{if_exists(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [view_name]}, + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{view_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::view_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [view_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{view_name}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [VIEW if_exists view_name]<<}, + Parse::RecDescent::_tracefirst($text), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{view_drop}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{view_drop}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{view_drop}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::statement +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"statement"}; + + Parse::RecDescent::_trace(q{Trying rule: [statement]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [begin_transaction]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{statement}); + %item = (__RULE__ => q{statement}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [begin_transaction]}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::begin_transaction($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [begin_transaction]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{begin_transaction}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [begin_transaction]<<}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [commit]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{statement}); + %item = (__RULE__ => q{statement}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [commit]}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::commit($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [commit]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{commit}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [commit]<<}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[2]; + $text = $_[1]; + my $_savetext; + @item = (q{statement}); + %item = (__RULE__ => q{statement}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [drop]}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::drop($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [drop]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{drop}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [drop]<<}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [comment]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[3]; + $text = $_[1]; + my $_savetext; + @item = (q{statement}); + %item = (__RULE__ => q{statement}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [comment]}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::comment($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [comment]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{comment}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [comment]<<}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [create]}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[4]; + $text = $_[1]; + my $_savetext; + @item = (q{statement}); + %item = (__RULE__ => q{statement}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [create]}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::create($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [create]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{create}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [create]<<}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched) + { + + Parse::RecDescent::_trace(q{Trying production: []}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[5]; + + my $_savetext; + @item = (q{statement}); + %item = (__RULE__ => q{statement}); + my $repcount = 0; + + + + + Parse::RecDescent::_trace(q{Trying directive: []}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $_tok = do { if (1) { do { + my $rule = $item[0]; + $rule =~ s/_/ /g; + #WAS: Parse::RecDescent::_error("Invalid $rule: " . $expectation->message() ,$thisline); + push @{$thisparser->{errors}}, ["Invalid $rule: " . $expectation->message() ,$thisline]; + } unless $_noactions; undef } else {0} }; + if (defined($_tok)) + { + Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + } + else + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + } + + last unless defined $_tok; + push @item, $item{__DIRECTIVE1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: []<<}, + Parse::RecDescent::_tracefirst($text), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{statement}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{statement}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{statement}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::field_name +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"field_name"}; + + Parse::RecDescent::_trace(q{Trying rule: [field_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [NAME]}, + Parse::RecDescent::_tracefirst($_[1]), + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{field_name}); + %item = (__RULE__ => q{field_name}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [NAME]}, + Parse::RecDescent::_tracefirst($text), + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::NAME($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [NAME]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{NAME}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [NAME]<<}, + Parse::RecDescent::_tracefirst($text), + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{field_name}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{field_name}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{field_name}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::eofile +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"eofile"}; + + Parse::RecDescent::_trace(q{Trying rule: [eofile]}, + Parse::RecDescent::_tracefirst($_[1]), + q{eofile}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/^\\Z/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{eofile}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{eofile}); + %item = (__RULE__ => q{eofile}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/^\\Z/]}, Parse::RecDescent::_tracefirst($text), + q{eofile}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:^\Z)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/^\\Z/]<<}, + Parse::RecDescent::_tracefirst($text), + q{eofile}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{eofile}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{eofile}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{eofile}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{eofile}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::startrule +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"startrule"}; + + Parse::RecDescent::_trace(q{Trying rule: [startrule]}, + Parse::RecDescent::_tracefirst($_[1]), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [statement eofile]}, + Parse::RecDescent::_tracefirst($_[1]), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{startrule}); + %item = (__RULE__ => q{startrule}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [statement]}, + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::statement, 1, 100000000, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [statement]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{statement(s)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [eofile]}, + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{eofile})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::eofile($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [eofile]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{eofile}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + tables => \%tables, + views => \@views, + triggers => \@triggers, + } +}; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [statement eofile]<<}, + Parse::RecDescent::_tracefirst($text), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{startrule}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{startrule}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{startrule}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::TRANSACTION +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"TRANSACTION"}; + + Parse::RecDescent::_trace(q{Trying rule: [TRANSACTION]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TRANSACTION}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/transaction/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TRANSACTION}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{TRANSACTION}); + %item = (__RULE__ => q{TRANSACTION}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/transaction/i]}, Parse::RecDescent::_tracefirst($text), + q{TRANSACTION}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:transaction)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/transaction/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{TRANSACTION}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{TRANSACTION}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{TRANSACTION}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{TRANSACTION}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{TRANSACTION}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::VALUE +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"VALUE"}; + + Parse::RecDescent::_trace(q{Trying rule: [VALUE]}, + Parse::RecDescent::_tracefirst($_[1]), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/[-+]?\\.?\\d+(?:[eE]\\d+)?/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{VALUE}); + %item = (__RULE__ => q{VALUE}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/[-+]?\\.?\\d+(?:[eE]\\d+)?/]}, Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[-+]?\.?\d+(?:[eE]\d+)?)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $item[1] }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/[-+]?\\.?\\d+(?:[eE]\\d+)?/]<<}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/'.*?'/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{VALUE}); + %item = (__RULE__ => q{VALUE}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/'.*?'/]}, Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:'.*?')//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + # remove leading/trailing quotes + my $val = $item[1]; + $val =~ s/^['"]|['"]$//g; + $return = $val; + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/'.*?'/]<<}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/NULL/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[2]; + $text = $_[1]; + my $_savetext; + @item = (q{VALUE}); + %item = (__RULE__ => q{VALUE}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/NULL/]}, Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:NULL)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { 'NULL' }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/NULL/]<<}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/CURRENT_TIMESTAMP/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[3]; + $text = $_[1]; + my $_savetext; + @item = (q{VALUE}); + %item = (__RULE__ => q{VALUE}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/CURRENT_TIMESTAMP/i]}, Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:CURRENT_TIMESTAMP)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { 'CURRENT_TIMESTAMP' }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/CURRENT_TIMESTAMP/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{VALUE}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{VALUE}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{VALUE}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::END_C +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"END_C"}; + + Parse::RecDescent::_trace(q{Trying rule: [END_C]}, + Parse::RecDescent::_tracefirst($_[1]), + q{END_C}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/end/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{END_C}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{END_C}); + %item = (__RULE__ => q{END_C}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/end/i]}, Parse::RecDescent::_tracefirst($text), + q{END_C}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:end)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/end/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{END_C}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{END_C}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{END_C}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{END_C}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{END_C}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::sort_order +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"sort_order"}; + + Parse::RecDescent::_trace(q{Trying rule: [sort_order]}, + Parse::RecDescent::_tracefirst($_[1]), + q{sort_order}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/(ASC|DESC)/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{sort_order}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{sort_order}); + %item = (__RULE__ => q{sort_order}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/(ASC|DESC)/i]}, Parse::RecDescent::_tracefirst($text), + q{sort_order}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(ASC|DESC))//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/(ASC|DESC)/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{sort_order}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{sort_order}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{sort_order}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{sort_order}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{sort_order}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::before_or_after +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"before_or_after"}; + + Parse::RecDescent::_trace(q{Trying rule: [before_or_after]}, + Parse::RecDescent::_tracefirst($_[1]), + q{before_or_after}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/(before|after)/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{before_or_after}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{before_or_after}); + %item = (__RULE__ => q{before_or_after}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/(before|after)/i]}, Parse::RecDescent::_tracefirst($text), + q{before_or_after}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(before|after))//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{before_or_after}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $return = lc $1 }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/(before|after)/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{before_or_after}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{before_or_after}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{before_or_after}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{before_or_after}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{before_or_after}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::tbl_drop +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"tbl_drop"}; + + Parse::RecDescent::_trace(q{Trying rule: [tbl_drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [TABLE table_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{tbl_drop}); + %item = (__RULE__ => q{tbl_drop}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [TABLE]}, + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::TABLE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [TABLE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TABLE}} = $_tok; + push @item, $_tok; + + } + + + + Parse::RecDescent::_trace(q{Trying directive: []}, + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + $_tok = do { $commit = 1 }; + if (defined($_tok)) + { + Parse::RecDescent::_trace(q{>>Matched directive<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + } + else + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + } + + last unless defined $_tok; + push @item, $item{__DIRECTIVE1__}=$_tok; + + + Parse::RecDescent::_trace(q{Trying subrule: [table_name]}, + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{table_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::table_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [table_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{table_name}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [TABLE table_name]<<}, + Parse::RecDescent::_tracefirst($text), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{tbl_drop}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{tbl_drop}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{tbl_drop}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::trg_drop +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"trg_drop"}; + + Parse::RecDescent::_trace(q{Trying rule: [trg_drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [TRIGGER if_exists trigger_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{trg_drop}); + %item = (__RULE__ => q{trg_drop}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [TRIGGER]}, + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::TRIGGER($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [TRIGGER]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TRIGGER}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [if_exists]}, + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{if_exists})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::if_exists, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [if_exists]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{if_exists(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [trigger_name]}, + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{trigger_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::trigger_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [trigger_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{trigger_name}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [TRIGGER if_exists trigger_name]<<}, + Parse::RecDescent::_tracefirst($text), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{trg_drop}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{trg_drop}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{trg_drop}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::_alternation_1_of_production_1_of_rule_drop +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"_alternation_1_of_production_1_of_rule_drop"}; + + Parse::RecDescent::_trace(q{Trying rule: [_alternation_1_of_production_1_of_rule_drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [tbl_drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{_alternation_1_of_production_1_of_rule_drop}); + %item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_drop}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [tbl_drop]}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::tbl_drop($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [tbl_drop]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{tbl_drop}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [tbl_drop]<<}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [view_drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{_alternation_1_of_production_1_of_rule_drop}); + %item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_drop}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [view_drop]}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::view_drop($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [view_drop]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{view_drop}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [view_drop]<<}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [trg_drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[2]; + $text = $_[1]; + my $_savetext; + @item = (q{_alternation_1_of_production_1_of_rule_drop}); + %item = (__RULE__ => q{_alternation_1_of_production_1_of_rule_drop}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [trg_drop]}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::trg_drop($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [trg_drop]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{trg_drop}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [trg_drop]<<}, + Parse::RecDescent::_tracefirst($text), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{_alternation_1_of_production_1_of_rule_drop}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::view_name +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"view_name"}; + + Parse::RecDescent::_trace(q{Trying rule: [view_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [qualified_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{view_name}); + %item = (__RULE__ => q{view_name}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [qualified_name]}, + Parse::RecDescent::_tracefirst($text), + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::qualified_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [qualified_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{qualified_name}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [qualified_name]<<}, + Parse::RecDescent::_tracefirst($text), + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{view_name}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{view_name}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{view_name}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::parens_value_list +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"parens_value_list"}; + + Parse::RecDescent::_trace(q{Trying rule: [parens_value_list]}, + Parse::RecDescent::_tracefirst($_[1]), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: ['(' ')']}, + Parse::RecDescent::_tracefirst($_[1]), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{parens_value_list}); + %item = (__RULE__ => q{parens_value_list}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: ['(']}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\(//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING1__}=$&; + + + Parse::RecDescent::_trace(q{Trying operator: []}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{})->at($text); + + $_tok = undef; + OPLOOP: while (1) + { + $repcount = 0; + my @item; + + # MATCH LEFTARG + + Parse::RecDescent::_trace(q{Trying subrule: [VALUE]}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{VALUE})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::VALUE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [VALUE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{VALUE}} = $_tok; + push @item, $_tok; + + } + + + $repcount++; + + my $savetext = $text; + my $backtrack; + + # MATCH (OP RIGHTARG)(s) + while ($repcount < 100000000) + { + $backtrack = 0; + + Parse::RecDescent::_trace(q{Trying terminal: [/,/]}, Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{/,/})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:,)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + pop @item; + if (defined $1) {push @item, $item{'VALUE(s)'}=$1; $backtrack=1;} + + Parse::RecDescent::_trace(q{Trying subrule: [VALUE]}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{VALUE})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::VALUE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [VALUE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{VALUE}} = $_tok; + push @item, $_tok; + + } + + $savetext = $text; + $repcount++; + } + $text = $savetext; + pop @item if $backtrack; + + unless (@item) { undef $_tok; last } + $_tok = [ @item ]; + last; + } + + unless ($repcount>=1) + { + Parse::RecDescent::_trace(q{<]>>}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [} + . qq{@{$_tok||[]}} . q{]}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + + push @item, $item{'VALUE(s)'}=$_tok||[]; + + + Parse::RecDescent::_trace(q{Trying terminal: [')']}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{')'})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING2__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $item[2] }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: ['(' ')']<<}, + Parse::RecDescent::_tracefirst($text), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{parens_value_list}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{parens_value_list}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{parens_value_list}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::commit +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"commit"}; + + Parse::RecDescent::_trace(q{Trying rule: [commit]}, + Parse::RecDescent::_tracefirst($_[1]), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/commit/i SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{commit}); + %item = (__RULE__ => q{commit}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/commit/i]}, Parse::RecDescent::_tracefirst($text), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:commit)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [/commit/i SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{commit}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{commit}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{commit}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::CHECK_C +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"CHECK_C"}; + + Parse::RecDescent::_trace(q{Trying rule: [CHECK_C]}, + Parse::RecDescent::_tracefirst($_[1]), + q{CHECK_C}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/check/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{CHECK_C}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{CHECK_C}); + %item = (__RULE__ => q{CHECK_C}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/check/i]}, Parse::RecDescent::_tracefirst($text), + q{CHECK_C}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:check)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/check/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{CHECK_C}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{CHECK_C}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{CHECK_C}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{CHECK_C}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{CHECK_C}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::SELECT +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"SELECT"}; + + Parse::RecDescent::_trace(q{Trying rule: [SELECT]}, + Parse::RecDescent::_tracefirst($_[1]), + q{SELECT}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/select/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{SELECT}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{SELECT}); + %item = (__RULE__ => q{SELECT}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/select/i]}, Parse::RecDescent::_tracefirst($text), + q{SELECT}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:select)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/select/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{SELECT}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{SELECT}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{SELECT}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{SELECT}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{SELECT}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::trigger_step +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"trigger_step"}; + + Parse::RecDescent::_trace(q{Trying rule: [trigger_step]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/(select|delete|insert|update)/i statement_body SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{trigger_step}); + %item = (__RULE__ => q{trigger_step}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/(select|delete|insert|update)/i]}, Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(select|delete|insert|update))//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [statement_body]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{statement_body})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::statement_body, 0, 100000000, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [statement_body]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{statement_body(s?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = join( ' ', $item[1], join ' ', @{ $item[2] || [] } ) + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/(select|delete|insert|update)/i statement_body SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{trigger_step}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{trigger_step}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{trigger_step}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::table_name +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"table_name"}; + + Parse::RecDescent::_trace(q{Trying rule: [table_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [qualified_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{table_name}); + %item = (__RULE__ => q{table_name}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [qualified_name]}, + Parse::RecDescent::_tracefirst($text), + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::qualified_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [qualified_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{qualified_name}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [qualified_name]<<}, + Parse::RecDescent::_tracefirst($text), + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{table_name}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{table_name}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{table_name}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::type +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"type"}; + + Parse::RecDescent::_trace(q{Trying rule: [type]}, + Parse::RecDescent::_tracefirst($_[1]), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [WORD parens_value_list]}, + Parse::RecDescent::_tracefirst($_[1]), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{type}); + %item = (__RULE__ => q{type}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [WORD]}, + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::WORD($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [WORD]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{WORD}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [parens_value_list]}, + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{parens_value_list})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::parens_value_list, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [parens_value_list]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{parens_value_list(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + type => $item[1], + size => $item[2][0], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [WORD parens_value_list]<<}, + Parse::RecDescent::_tracefirst($text), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{type}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{type}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{type}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{type}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::NOT_NULL +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"NOT_NULL"}; + + Parse::RecDescent::_trace(q{Trying rule: [NOT_NULL]}, + Parse::RecDescent::_tracefirst($_[1]), + q{NOT_NULL}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/not null/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{NOT_NULL}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{NOT_NULL}); + %item = (__RULE__ => q{NOT_NULL}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/not null/i]}, Parse::RecDescent::_tracefirst($text), + q{NOT_NULL}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:not null)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/not null/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{NOT_NULL}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{NOT_NULL}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{NOT_NULL}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{NOT_NULL}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{NOT_NULL}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::TABLE +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"TABLE"}; + + Parse::RecDescent::_trace(q{Trying rule: [TABLE]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TABLE}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/table/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TABLE}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{TABLE}); + %item = (__RULE__ => q{TABLE}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/table/i]}, Parse::RecDescent::_tracefirst($text), + q{TABLE}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:table)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/table/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{TABLE}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{TABLE}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{TABLE}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{TABLE}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{TABLE}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::trigger_name +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"trigger_name"}; + + Parse::RecDescent::_trace(q{Trying rule: [trigger_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [qualified_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{trigger_name}); + %item = (__RULE__ => q{trigger_name}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [qualified_name]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::qualified_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [qualified_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{qualified_name}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [qualified_name]<<}, + Parse::RecDescent::_tracefirst($text), + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{trigger_name}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{trigger_name}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{trigger_name}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::instead_of +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"instead_of"}; + + Parse::RecDescent::_trace(q{Trying rule: [instead_of]}, + Parse::RecDescent::_tracefirst($_[1]), + q{instead_of}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/instead of/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{instead_of}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{instead_of}); + %item = (__RULE__ => q{instead_of}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/instead of/i]}, Parse::RecDescent::_tracefirst($text), + q{instead_of}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:instead of)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/instead of/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{instead_of}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{instead_of}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{instead_of}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{instead_of}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{instead_of}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::drop +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"drop"}; + + Parse::RecDescent::_trace(q{Trying rule: [drop]}, + Parse::RecDescent::_tracefirst($_[1]), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/drop/i tbl_drop, or view_drop, or trg_drop SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{drop}); + %item = (__RULE__ => q{drop}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/drop/i]}, Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:drop)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [_alternation_1_of_production_1_of_rule_drop]}, + Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{tbl_drop, or view_drop, or trg_drop})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::_alternation_1_of_production_1_of_rule_drop($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [_alternation_1_of_production_1_of_rule_drop]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{_alternation_1_of_production_1_of_rule_drop}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [/drop/i tbl_drop, or view_drop, or trg_drop SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{drop}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{drop}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{drop}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::WHEN +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"WHEN"}; + + Parse::RecDescent::_trace(q{Trying rule: [WHEN]}, + Parse::RecDescent::_tracefirst($_[1]), + q{WHEN}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/when/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{WHEN}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{WHEN}); + %item = (__RULE__ => q{WHEN}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/when/i]}, Parse::RecDescent::_tracefirst($text), + q{WHEN}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:when)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/when/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{WHEN}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{WHEN}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{WHEN}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{WHEN}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{WHEN}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::TEMPORARY +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"TEMPORARY"}; + + Parse::RecDescent::_trace(q{Trying rule: [TEMPORARY]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TEMPORARY}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/temp(orary)?/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TEMPORARY}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{TEMPORARY}); + %item = (__RULE__ => q{TEMPORARY}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/temp(orary)?/i]}, Parse::RecDescent::_tracefirst($text), + q{TEMPORARY}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:temp(orary)?)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{TEMPORARY}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { 1 }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/temp(orary)?/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{TEMPORARY}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{TEMPORARY}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{TEMPORARY}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{TEMPORARY}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{TEMPORARY}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::database_event +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"database_event"}; + + Parse::RecDescent::_trace(q{Trying rule: [database_event]}, + Parse::RecDescent::_tracefirst($_[1]), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/(delete|insert|update)/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{database_event}); + %item = (__RULE__ => q{database_event}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/(delete|insert|update)/i]}, Parse::RecDescent::_tracefirst($text), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(delete|insert|update))//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/(delete|insert|update)/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/update of/i column_list]}, + Parse::RecDescent::_tracefirst($_[1]), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{database_event}); + %item = (__RULE__ => q{database_event}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/update of/i]}, Parse::RecDescent::_tracefirst($text), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:update of)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [column_list]}, + Parse::RecDescent::_tracefirst($text), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{column_list})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::column_list($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [column_list]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{column_list}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [/update of/i column_list]<<}, + Parse::RecDescent::_tracefirst($text), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{database_event}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{database_event}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{database_event}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::definition +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"definition"}; + + Parse::RecDescent::_trace(q{Trying rule: [definition]}, + Parse::RecDescent::_tracefirst($_[1]), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [constraint_def]}, + Parse::RecDescent::_tracefirst($_[1]), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{definition}); + %item = (__RULE__ => q{definition}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [constraint_def]}, + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::constraint_def($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [constraint_def]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{constraint_def}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [constraint_def]<<}, + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [column_def]}, + Parse::RecDescent::_tracefirst($_[1]), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{definition}); + %item = (__RULE__ => q{definition}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [column_def]}, + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::column_def($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [column_def]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{column_def}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [column_def]<<}, + Parse::RecDescent::_tracefirst($text), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{definition}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{definition}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{definition}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::UNIQUE +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"UNIQUE"}; + + Parse::RecDescent::_trace(q{Trying rule: [UNIQUE]}, + Parse::RecDescent::_tracefirst($_[1]), + q{UNIQUE}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/unique/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{UNIQUE}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{UNIQUE}); + %item = (__RULE__ => q{UNIQUE}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/unique/i]}, Parse::RecDescent::_tracefirst($text), + q{UNIQUE}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:unique)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{UNIQUE}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { 1 }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/unique/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{UNIQUE}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{UNIQUE}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{UNIQUE}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{UNIQUE}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{UNIQUE}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::expr +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"expr"}; + + Parse::RecDescent::_trace(q{Trying rule: [expr]}, + Parse::RecDescent::_tracefirst($_[1]), + q{expr}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/[^)]+/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{expr}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{expr}); + %item = (__RULE__ => q{expr}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/[^)]+/]}, Parse::RecDescent::_tracefirst($text), + q{expr}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^)]+)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/[^)]+/]<<}, + Parse::RecDescent::_tracefirst($text), + q{expr}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{expr}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{expr}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{expr}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{expr}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::AS +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"AS"}; + + Parse::RecDescent::_trace(q{Trying rule: [AS]}, + Parse::RecDescent::_tracefirst($_[1]), + q{AS}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/as/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{AS}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{AS}); + %item = (__RULE__ => q{AS}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/as/i]}, Parse::RecDescent::_tracefirst($text), + q{AS}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:as)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/as/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{AS}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{AS}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{AS}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{AS}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{AS}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::column_constraint +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"column_constraint"}; + + Parse::RecDescent::_trace(q{Trying rule: [column_constraint]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [NOT_NULL conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{column_constraint}); + %item = (__RULE__ => q{column_constraint}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [NOT_NULL]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::NOT_NULL($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [NOT_NULL]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{NOT_NULL}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + type => 'not_null', + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [NOT_NULL conflict_clause]<<}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [PRIMARY_KEY sort_order conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{column_constraint}); + %item = (__RULE__ => q{column_constraint}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [PRIMARY_KEY]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::PRIMARY_KEY($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [PRIMARY_KEY]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{PRIMARY_KEY}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [sort_order]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{sort_order})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::sort_order, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [sort_order]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{sort_order(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + type => 'primary_key', + sort_order => $item[2][0], + on_conflict => $item[2][0], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [PRIMARY_KEY sort_order conflict_clause]<<}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [UNIQUE conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[2]; + $text = $_[1]; + my $_savetext; + @item = (q{column_constraint}); + %item = (__RULE__ => q{column_constraint}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [UNIQUE]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::UNIQUE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [UNIQUE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{UNIQUE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + type => 'unique', + on_conflict => $item[2][0], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [UNIQUE conflict_clause]<<}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [CHECK_C '(' expr ')' conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[3]; + $text = $_[1]; + my $_savetext; + @item = (q{column_constraint}); + %item = (__RULE__ => q{column_constraint}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [CHECK_C]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::CHECK_C($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [CHECK_C]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{CHECK_C}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying terminal: ['(']}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{'('})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\(//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [expr]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{expr})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{expr}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying terminal: [')']}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{')'})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING2__}=$&; + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + type => 'check', + expression => $item[3], + on_conflict => $item[5][0], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [CHECK_C '(' expr ')' conflict_clause]<<}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [DEFAULT VALUE]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[4]; + $text = $_[1]; + my $_savetext; + @item = (q{column_constraint}); + %item = (__RULE__ => q{column_constraint}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [DEFAULT]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::DEFAULT($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [DEFAULT]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{DEFAULT}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [VALUE]}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{VALUE})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::VALUE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [VALUE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{VALUE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + type => 'default', + value => $item[2], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [DEFAULT VALUE]<<}, + Parse::RecDescent::_tracefirst($text), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{column_constraint}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{column_constraint}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{column_constraint}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"conflict_clause"}; + + Parse::RecDescent::_trace(q{Trying rule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($_[1]), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/on conflict/i conflict_algorigthm]}, + Parse::RecDescent::_tracefirst($_[1]), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{conflict_clause}); + %item = (__RULE__ => q{conflict_clause}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/on conflict/i]}, Parse::RecDescent::_tracefirst($text), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:on conflict)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [conflict_algorigthm]}, + Parse::RecDescent::_tracefirst($text), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{conflict_algorigthm})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_algorigthm($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [conflict_algorigthm]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_algorigthm}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [/on conflict/i conflict_algorigthm]<<}, + Parse::RecDescent::_tracefirst($text), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{conflict_clause}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{conflict_clause}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{conflict_clause}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::trigger_action +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"trigger_action"}; + + Parse::RecDescent::_trace(q{Trying rule: [trigger_action]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [for_each when BEGIN_C trigger_step END_C]}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{trigger_action}); + %item = (__RULE__ => q{trigger_action}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [for_each]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::for_each, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [for_each]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{for_each(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [when]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{when})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::when, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [when]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{when(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [BEGIN_C]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{BEGIN_C})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::BEGIN_C($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [BEGIN_C]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{BEGIN_C}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [trigger_step]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{trigger_step})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::trigger_step, 1, 100000000, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [trigger_step]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{trigger_step(s)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [END_C]}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{END_C})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::END_C($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [END_C]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{END_C}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = { + for_each => $item[1][0], + when => $item[2][0], + steps => $item[4], + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [for_each when BEGIN_C trigger_step END_C]<<}, + Parse::RecDescent::_tracefirst($text), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{trigger_action}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{trigger_action}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{trigger_action}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::nonstring +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"nonstring"}; + + Parse::RecDescent::_trace(q{Trying rule: [nonstring]}, + Parse::RecDescent::_tracefirst($_[1]), + q{nonstring}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/[^;\\'"]+/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{nonstring}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{nonstring}); + %item = (__RULE__ => q{nonstring}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/[^;\\'"]+/]}, Parse::RecDescent::_tracefirst($text), + q{nonstring}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^;\'"]+)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/[^;\\'"]+/]<<}, + Parse::RecDescent::_tracefirst($text), + q{nonstring}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{nonstring}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{nonstring}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{nonstring}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{nonstring}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::column_list +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"column_list"}; + + Parse::RecDescent::_trace(q{Trying rule: [column_list]}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: []}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{column_list}); + %item = (__RULE__ => q{column_list}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying operator: []}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{})->at($text); + + $_tok = undef; + OPLOOP: while (1) + { + $repcount = 0; + my @item; + + # MATCH LEFTARG + + Parse::RecDescent::_trace(q{Trying subrule: [field_name]}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{field_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::field_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [field_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{field_name}} = $_tok; + push @item, $_tok; + + } + + + $repcount++; + + my $savetext = $text; + my $backtrack; + + # MATCH (OP RIGHTARG)(s) + while ($repcount < 100000000) + { + $backtrack = 0; + + Parse::RecDescent::_trace(q{Trying terminal: [/,/]}, Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{/,/})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:,)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + pop @item; + if (defined $1) {push @item, $item{'field_name(s)'}=$1; $backtrack=1;} + + Parse::RecDescent::_trace(q{Trying subrule: [field_name]}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{field_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::field_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [field_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{field_name}} = $_tok; + push @item, $_tok; + + } + + $savetext = $text; + $repcount++; + } + $text = $savetext; + pop @item if $backtrack; + + unless (@item) { undef $_tok; last } + $_tok = [ @item ]; + last; + } + + unless ($repcount>=1) + { + Parse::RecDescent::_trace(q{<]>>}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [} + . qq{@{$_tok||[]}} . q{]}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + + push @item, $item{'field_name(s)'}=$_tok||[]; + + + + Parse::RecDescent::_trace(q{>>Matched production: []<<}, + Parse::RecDescent::_tracefirst($text), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{column_list}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{column_list}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{column_list}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"SEMICOLON"}; + + Parse::RecDescent::_trace(q{Trying rule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{SEMICOLON}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [';']}, + Parse::RecDescent::_tracefirst($_[1]), + q{SEMICOLON}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{SEMICOLON}); + %item = (__RULE__ => q{SEMICOLON}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [';']}, + Parse::RecDescent::_tracefirst($text), + q{SEMICOLON}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\;//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [';']<<}, + Parse::RecDescent::_tracefirst($text), + q{SEMICOLON}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{SEMICOLON}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{SEMICOLON}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{SEMICOLON}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{SEMICOLON}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::create +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"create"}; + + Parse::RecDescent::_trace(q{Trying rule: [create]}, + Parse::RecDescent::_tracefirst($_[1]), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [CREATE TEMPORARY UNIQUE INDEX WORD ON table_name parens_field_list conflict_clause SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{create}); + %item = (__RULE__ => q{create}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [CREATE]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::CREATE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [CREATE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{CREATE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [TEMPORARY]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{TEMPORARY})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::TEMPORARY, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [TEMPORARY]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TEMPORARY(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [UNIQUE]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{UNIQUE})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::UNIQUE, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [UNIQUE]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{UNIQUE(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [INDEX]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{INDEX})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::INDEX($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [INDEX]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{INDEX}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [WORD]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{WORD})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::WORD($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [WORD]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{WORD}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [ON]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{ON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::ON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [ON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{ON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [table_name]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{table_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::table_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [table_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{table_name}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [parens_field_list]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{parens_field_list})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::parens_field_list($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [parens_field_list]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{parens_field_list}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [conflict_clause]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{conflict_clause})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::conflict_clause, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [conflict_clause]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{conflict_clause(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + my $db_name = $item[7]->{'db_name'} || ''; + my $table_name = $item[7]->{'name'}; + + my $index = { + name => $item[5], + columns => $item[8], + on_conflict => $item[9][0], + is_temporary => $item[2][0] ? 1 : 0, + }; + + my $is_unique = $item[3][0]; + + if ( $is_unique ) { + $index->{'type'} = 'unique'; + push @{ $tables{ $table_name }{'constraints'} }, $index; + } + else { + push @{ $tables{ $table_name }{'indices'} }, $index; + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [CREATE TEMPORARY UNIQUE INDEX WORD ON table_name parens_field_list conflict_clause SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [CREATE TEMPORARY TABLE table_name '(' ')' SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{create}); + %item = (__RULE__ => q{create}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [CREATE]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::CREATE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [CREATE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{CREATE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [TEMPORARY]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{TEMPORARY})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::TEMPORARY, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [TEMPORARY]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TEMPORARY(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [TABLE]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{TABLE})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::TABLE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [TABLE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TABLE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [table_name]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{table_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::table_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [table_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{table_name}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying terminal: ['(']}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{'('})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\(//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING1__}=$&; + + + Parse::RecDescent::_trace(q{Trying operator: []}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{})->at($text); + + $_tok = undef; + OPLOOP: while (1) + { + $repcount = 0; + my @item; + + # MATCH LEFTARG + + Parse::RecDescent::_trace(q{Trying subrule: [definition]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{definition})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::definition($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [definition]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{definition}} = $_tok; + push @item, $_tok; + + } + + + $repcount++; + + my $savetext = $text; + my $backtrack; + + # MATCH (OP RIGHTARG)(s) + while ($repcount < 100000000) + { + $backtrack = 0; + + Parse::RecDescent::_trace(q{Trying terminal: [/,/]}, Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{/,/})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:,)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + pop @item; + if (defined $1) {push @item, $item{'definition(s)'}=$1; $backtrack=1;} + + Parse::RecDescent::_trace(q{Trying subrule: [definition]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{definition})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::definition($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [definition]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{definition}} = $_tok; + push @item, $_tok; + + } + + $savetext = $text; + $repcount++; + } + $text = $savetext; + pop @item if $backtrack; + + unless (@item) { undef $_tok; last } + $_tok = [ @item ]; + last; + } + + unless ($repcount>=1) + { + Parse::RecDescent::_trace(q{<]>>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched operator: []<< (return value: [} + . qq{@{$_tok||[]}} . q{]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + + push @item, $item{'definition(s)'}=$_tok||[]; + + + Parse::RecDescent::_trace(q{Trying terminal: [')']}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{')'})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING2__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + my $db_name = $item[4]->{'db_name'} || ''; + my $table_name = $item[4]->{'name'}; + + $tables{ $table_name }{'name'} = $table_name; + $tables{ $table_name }{'is_temporary'} = $item[2][0] ? 1 : 0; + $tables{ $table_name }{'order'} = ++$table_order; + + for my $def ( @{ $item[6] } ) { + if ( $def->{'supertype'} eq 'column' ) { + push @{ $tables{ $table_name }{'columns'} }, $def; + } + elsif ( $def->{'supertype'} eq 'constraint' ) { + push @{ $tables{ $table_name }{'constraints'} }, $def; + } + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [CREATE TEMPORARY TABLE table_name '(' ')' SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [CREATE TEMPORARY TRIGGER NAME before_or_after database_event ON table_name trigger_action SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[2]; + $text = $_[1]; + my $_savetext; + @item = (q{create}); + %item = (__RULE__ => q{create}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [CREATE]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::CREATE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [CREATE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{CREATE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [TEMPORARY]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{TEMPORARY})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::TEMPORARY, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [TEMPORARY]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TEMPORARY(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [TRIGGER]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{TRIGGER})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::TRIGGER($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [TRIGGER]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TRIGGER}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [NAME]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{NAME})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::NAME($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [NAME]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{NAME}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [before_or_after]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{before_or_after})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::before_or_after, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [before_or_after]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{before_or_after(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [database_event]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{database_event})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::database_event($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [database_event]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{database_event}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [ON]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{ON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::ON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [ON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{ON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [table_name]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{table_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::table_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [table_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{table_name}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [trigger_action]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{trigger_action})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::trigger_action($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [trigger_action]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{trigger_action}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + my $table_name = $item[8]->{'name'}; + push @triggers, { + name => $item[4], + is_temporary => $item[2][0] ? 1 : 0, + when => $item[5][0], + instead_of => 0, + db_events => [ $item[6] ], + action => $item[9], + on_table => $table_name, + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [CREATE TEMPORARY TRIGGER NAME before_or_after database_event ON table_name trigger_action SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [CREATE TEMPORARY TRIGGER NAME instead_of database_event ON view_name trigger_action]}, + Parse::RecDescent::_tracefirst($_[1]), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[3]; + $text = $_[1]; + my $_savetext; + @item = (q{create}); + %item = (__RULE__ => q{create}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [CREATE]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::CREATE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [CREATE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{CREATE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [TEMPORARY]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{TEMPORARY})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::TEMPORARY, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [TEMPORARY]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TEMPORARY(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [TRIGGER]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{TRIGGER})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::TRIGGER($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [TRIGGER]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TRIGGER}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [NAME]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{NAME})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::NAME($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [NAME]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{NAME}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [instead_of]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{instead_of})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::instead_of($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [instead_of]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{instead_of}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [database_event]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{database_event})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::database_event($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [database_event]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{database_event}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [ON]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{ON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::ON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [ON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{ON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [view_name]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{view_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::view_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [view_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{view_name}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [trigger_action]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{trigger_action})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::trigger_action($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [trigger_action]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{trigger_action}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + my $table_name = $item[8]->{'name'}; + push @triggers, { + name => $item[4], + is_temporary => $item[2][0] ? 1 : 0, + when => undef, + instead_of => 1, + db_events => [ $item[6] ], + action => $item[9], + on_table => $table_name, + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [CREATE TEMPORARY TRIGGER NAME instead_of database_event ON view_name trigger_action]<<}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [CREATE TEMPORARY VIEW view_name AS select_statement]}, + Parse::RecDescent::_tracefirst($_[1]), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[4]; + $text = $_[1]; + my $_savetext; + @item = (q{create}); + %item = (__RULE__ => q{create}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [CREATE]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::CREATE($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [CREATE]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{CREATE}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying repeated subrule: [TEMPORARY]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{TEMPORARY})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::TEMPORARY, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [TEMPORARY]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TEMPORARY(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [VIEW]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{VIEW})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::VIEW($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [VIEW]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{VIEW}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [view_name]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{view_name})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::view_name($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [view_name]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{view_name}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [AS]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{AS})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::AS($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [AS]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{AS}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [select_statement]}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{select_statement})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::select_statement($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [select_statement]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{select_statement}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + push @views, { + name => $item[4]->{'name'}, + sql => $item[6], + is_temporary => $item[2][0] ? 1 : 0, + } + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [CREATE TEMPORARY VIEW view_name AS select_statement]<<}, + Parse::RecDescent::_tracefirst($text), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{create}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{create}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{create}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{create}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::when +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"when"}; + + Parse::RecDescent::_trace(q{Trying rule: [when]}, + Parse::RecDescent::_tracefirst($_[1]), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [WHEN expr]}, + Parse::RecDescent::_tracefirst($_[1]), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{when}); + %item = (__RULE__ => q{when}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [WHEN]}, + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::WHEN($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [WHEN]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{WHEN}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying subrule: [expr]}, + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{expr})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::expr($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [expr]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{expr}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $item[2] }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [WHEN expr]<<}, + Parse::RecDescent::_tracefirst($text), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{when}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{when}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{when}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{when}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::NAME +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"NAME"}; + + Parse::RecDescent::_trace(q{Trying rule: [NAME]}, + Parse::RecDescent::_tracefirst($_[1]), + q{NAME}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/'?(\\w+)'?/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{NAME}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{NAME}); + %item = (__RULE__ => q{NAME}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/'?(\\w+)'?/]}, Parse::RecDescent::_tracefirst($text), + q{NAME}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:'?(\w+)'?)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{NAME}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $return = $1 }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/'?(\\w+)'?/]<<}, + Parse::RecDescent::_tracefirst($text), + q{NAME}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{NAME}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{NAME}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{NAME}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{NAME}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::ON +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"ON"}; + + Parse::RecDescent::_trace(q{Trying rule: [ON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{ON}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/on/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{ON}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{ON}); + %item = (__RULE__ => q{ON}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/on/i]}, Parse::RecDescent::_tracefirst($text), + q{ON}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:on)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/on/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{ON}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{ON}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{ON}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{ON}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{ON}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::DEFAULT +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"DEFAULT"}; + + Parse::RecDescent::_trace(q{Trying rule: [DEFAULT]}, + Parse::RecDescent::_tracefirst($_[1]), + q{DEFAULT}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/default/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{DEFAULT}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{DEFAULT}); + %item = (__RULE__ => q{DEFAULT}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/default/i]}, Parse::RecDescent::_tracefirst($text), + q{DEFAULT}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:default)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/default/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{DEFAULT}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{DEFAULT}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{DEFAULT}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{DEFAULT}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{DEFAULT}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::begin_transaction +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"begin_transaction"}; + + Parse::RecDescent::_trace(q{Trying rule: [begin_transaction]}, + Parse::RecDescent::_tracefirst($_[1]), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/begin/i TRANSACTION SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{begin_transaction}); + %item = (__RULE__ => q{begin_transaction}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/begin/i]}, Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:begin)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying repeated subrule: [TRANSACTION]}, + Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->is(q{TRANSACTION})->at($text); + + unless (defined ($_tok = $thisparser->_parserepeat($text, \&Parse::RecDescent::SQL::Translator::Grammar::SQLite::TRANSACTION, 0, 1, $_noactions,$expectation,undef))) + { + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched repeated subrule: [TRANSACTION]<< (} + . @$_tok . q{ times)}, + + Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{TRANSACTION(?)}} = $_tok; + push @item, $_tok; + + + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + + Parse::RecDescent::_trace(q{>>Matched production: [/begin/i TRANSACTION SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{begin_transaction}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{begin_transaction}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{begin_transaction}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::TRIGGER +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"TRIGGER"}; + + Parse::RecDescent::_trace(q{Trying rule: [TRIGGER]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TRIGGER}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/trigger/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{TRIGGER}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{TRIGGER}); + %item = (__RULE__ => q{TRIGGER}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/trigger/i]}, Parse::RecDescent::_tracefirst($text), + q{TRIGGER}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:trigger)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/trigger/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{TRIGGER}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{TRIGGER}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{TRIGGER}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{TRIGGER}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{TRIGGER}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::select_statement +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"select_statement"}; + + Parse::RecDescent::_trace(q{Trying rule: [select_statement]}, + Parse::RecDescent::_tracefirst($_[1]), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [SELECT /[^;]+/ SEMICOLON]}, + Parse::RecDescent::_tracefirst($_[1]), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{select_statement}); + %item = (__RULE__ => q{select_statement}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [SELECT]}, + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SELECT($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SELECT]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SELECT}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying terminal: [/[^;]+/]}, Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{/[^;]+/})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^;]+)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [SEMICOLON]}, + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{SEMICOLON})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::SEMICOLON($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [SEMICOLON]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{SEMICOLON}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + $return = join( ' ', $item[1], $item[2] ); + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [SELECT /[^;]+/ SEMICOLON]<<}, + Parse::RecDescent::_tracefirst($text), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{select_statement}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{select_statement}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{select_statement}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::if_exists +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"if_exists"}; + + Parse::RecDescent::_trace(q{Trying rule: [if_exists]}, + Parse::RecDescent::_tracefirst($_[1]), + q{if_exists}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/if exists/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{if_exists}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{if_exists}); + %item = (__RULE__ => q{if_exists}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/if exists/i]}, Parse::RecDescent::_tracefirst($text), + q{if_exists}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:if exists)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/if exists/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{if_exists}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{if_exists}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{if_exists}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{if_exists}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{if_exists}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::PRIMARY_KEY +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"PRIMARY_KEY"}; + + Parse::RecDescent::_trace(q{Trying rule: [PRIMARY_KEY]}, + Parse::RecDescent::_tracefirst($_[1]), + q{PRIMARY_KEY}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/primary key/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{PRIMARY_KEY}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{PRIMARY_KEY}); + %item = (__RULE__ => q{PRIMARY_KEY}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/primary key/i]}, Parse::RecDescent::_tracefirst($text), + q{PRIMARY_KEY}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:primary key)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/primary key/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{PRIMARY_KEY}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{PRIMARY_KEY}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{PRIMARY_KEY}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{PRIMARY_KEY}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{PRIMARY_KEY}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::CREATE +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"CREATE"}; + + Parse::RecDescent::_trace(q{Trying rule: [CREATE]}, + Parse::RecDescent::_tracefirst($_[1]), + q{CREATE}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/create/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{CREATE}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{CREATE}); + %item = (__RULE__ => q{CREATE}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/create/i]}, Parse::RecDescent::_tracefirst($text), + q{CREATE}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:create)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/create/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{CREATE}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{CREATE}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{CREATE}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{CREATE}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{CREATE}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::comment +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"comment"}; + + Parse::RecDescent::_trace(q{Trying rule: [comment]}, + Parse::RecDescent::_tracefirst($_[1]), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/^\\s*(?:#|-\{2\}).*\\n/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{comment}); + %item = (__RULE__ => q{comment}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/^\\s*(?:#|-\{2\}).*\\n/]}, Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:^\s*(?:#|-{2}).*\n)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + my $comment = $item[1]; + $comment =~ s/^\s*(#|-{2})\s*//; + $comment =~ s/\s*$//; + $return = $comment; + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/^\\s*(?:#|-\{2\}).*\\n/]<<}, + Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/\\/\\*/ /[^\\*]+/ /\\*\\//]}, + Parse::RecDescent::_tracefirst($_[1]), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{comment}); + %item = (__RULE__ => q{comment}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/\\/\\*/]}, Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\/\*)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying terminal: [/[^\\*]+/]}, Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{/[^\\*]+/})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:[^\*]+)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN2__}=$&; + + + Parse::RecDescent::_trace(q{Trying terminal: [/\\*\\//]}, Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{/\\*\\//})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:\*\/)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN3__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { + my $comment = $item[2]; + $comment =~ s/^\s*|\s*$//g; + $return = $comment; + }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/\\/\\*/ /[^\\*]+/ /\\*\\//]<<}, + Parse::RecDescent::_tracefirst($text), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{comment}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{comment}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{comment}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::BEGIN_C +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"BEGIN_C"}; + + Parse::RecDescent::_trace(q{Trying rule: [BEGIN_C]}, + Parse::RecDescent::_tracefirst($_[1]), + q{BEGIN_C}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/begin/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{BEGIN_C}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{BEGIN_C}); + %item = (__RULE__ => q{BEGIN_C}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/begin/i]}, Parse::RecDescent::_tracefirst($text), + q{BEGIN_C}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:begin)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/begin/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{BEGIN_C}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{BEGIN_C}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{BEGIN_C}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{BEGIN_C}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{BEGIN_C}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::qualified_name +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"qualified_name"}; + + Parse::RecDescent::_trace(q{Trying rule: [qualified_name]}, + Parse::RecDescent::_tracefirst($_[1]), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [NAME]}, + Parse::RecDescent::_tracefirst($_[1]), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{qualified_name}); + %item = (__RULE__ => q{qualified_name}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying subrule: [NAME]}, + Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::NAME($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [NAME]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{NAME}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $return = { name => $item[1] } }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [NAME]<<}, + Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/(\\w+)\\.(\\w+)/]}, + Parse::RecDescent::_tracefirst($_[1]), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[1]; + $text = $_[1]; + my $_savetext; + @item = (q{qualified_name}); + %item = (__RULE__ => q{qualified_name}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/(\\w+)\\.(\\w+)/]}, Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:(\w+)\.(\w+))//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $return = { db_name => $1, name => $2 } }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/(\\w+)\\.(\\w+)/]<<}, + Parse::RecDescent::_tracefirst($text), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{qualified_name}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{qualified_name}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{qualified_name}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::parens_field_list +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"parens_field_list"}; + + Parse::RecDescent::_trace(q{Trying rule: [parens_field_list]}, + Parse::RecDescent::_tracefirst($_[1]), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: ['(' column_list ')']}, + Parse::RecDescent::_tracefirst($_[1]), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{parens_field_list}); + %item = (__RULE__ => q{parens_field_list}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: ['(']}, + Parse::RecDescent::_tracefirst($text), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\(//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING1__}=$&; + + + Parse::RecDescent::_trace(q{Trying subrule: [column_list]}, + Parse::RecDescent::_tracefirst($text), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + if (1) { no strict qw{refs}; + $expectation->is(q{column_list})->at($text); + unless (defined ($_tok = Parse::RecDescent::SQL::Translator::Grammar::SQLite::column_list($thisparser,$text,$repeating,$_noactions,sub { \@arg }))) + { + + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + $expectation->failed(); + last; + } + Parse::RecDescent::_trace(q{>>Matched subrule: [column_list]<< (return value: [} + . $_tok . q{]}, + + Parse::RecDescent::_tracefirst($text), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + $item{q{column_list}} = $_tok; + push @item, $_tok; + + } + + Parse::RecDescent::_trace(q{Trying terminal: [')']}, + Parse::RecDescent::_tracefirst($text), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{')'})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A\)//) + { + + $expectation->failed(); + Parse::RecDescent::_trace(qq{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__STRING2__}=$&; + + + Parse::RecDescent::_trace(q{Trying action}, + Parse::RecDescent::_tracefirst($text), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + + + $_tok = ($_noactions) ? 0 : do { $item[2] }; + unless (defined $_tok) + { + Parse::RecDescent::_trace(q{<> (return value: [undef])}) + if defined $::RD_TRACE; + last; + } + Parse::RecDescent::_trace(q{>>Matched action<< (return value: [} + . $_tok . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $_tok; + $item{__ACTION1__}=$_tok; + + + + Parse::RecDescent::_trace(q{>>Matched production: ['(' column_list ')']<<}, + Parse::RecDescent::_tracefirst($text), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{parens_field_list}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{parens_field_list}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{parens_field_list}, + $tracelevel) + } + $_[1] = $text; + return $return; +} + +# ARGS ARE: ($parser, $text; $repeating, $_noactions, \@args) +sub Parse::RecDescent::SQL::Translator::Grammar::SQLite::VIEW +{ + my $thisparser = $_[0]; + use vars q{$tracelevel}; + local $tracelevel = ($tracelevel||0)+1; + $ERRORS = 0; + my $thisrule = $thisparser->{"rules"}{"VIEW"}; + + Parse::RecDescent::_trace(q{Trying rule: [VIEW]}, + Parse::RecDescent::_tracefirst($_[1]), + q{VIEW}, + $tracelevel) + if defined $::RD_TRACE; + + + my $err_at = @{$thisparser->{errors}}; + + my $score; + my $score_return; + my $_tok; + my $return = undef; + my $_matched=0; + my $commit=0; + my @item = (); + my %item = (); + my $repeating = defined($_[2]) && $_[2]; + my $_noactions = defined($_[3]) && $_[3]; + my @arg = defined $_[4] ? @{ &{$_[4]} } : (); + my %arg = ($#arg & 01) ? @arg : (@arg, undef); + my $text; + my $lastsep=""; + my $expectation = new Parse::RecDescent::Expectation($thisrule->expected()); + $expectation->at($_[1]); + + my $thisline; + tie $thisline, q{Parse::RecDescent::LineCounter}, \$text, $thisparser; + + + + while (!$_matched && !$commit) + { + + Parse::RecDescent::_trace(q{Trying production: [/view/i]}, + Parse::RecDescent::_tracefirst($_[1]), + q{VIEW}, + $tracelevel) + if defined $::RD_TRACE; + my $thisprod = $thisrule->{"prods"}[0]; + $text = $_[1]; + my $_savetext; + @item = (q{VIEW}); + %item = (__RULE__ => q{VIEW}); + my $repcount = 0; + + + Parse::RecDescent::_trace(q{Trying terminal: [/view/i]}, Parse::RecDescent::_tracefirst($text), + q{VIEW}, + $tracelevel) + if defined $::RD_TRACE; + $lastsep = ""; + $expectation->is(q{})->at($text); + + + unless ($text =~ s/\A($skip)/$lastsep=$1 and ""/e and $text =~ s/\A(?:view)//i) + { + + $expectation->failed(); + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + + last; + } + Parse::RecDescent::_trace(q{>>Matched terminal<< (return value: [} + . $& . q{])}, + Parse::RecDescent::_tracefirst($text)) + if defined $::RD_TRACE; + push @item, $item{__PATTERN1__}=$&; + + + + Parse::RecDescent::_trace(q{>>Matched production: [/view/i]<<}, + Parse::RecDescent::_tracefirst($text), + q{VIEW}, + $tracelevel) + if defined $::RD_TRACE; + $_matched = 1; + last; + } + + + unless ( $_matched || defined($return) || defined($score) ) + { + + + $_[1] = $text; # NOT SURE THIS IS NEEDED + Parse::RecDescent::_trace(q{<>}, + Parse::RecDescent::_tracefirst($_[1]), + q{VIEW}, + $tracelevel) + if defined $::RD_TRACE; + return undef; + } + if (!defined($return) && defined($score)) + { + Parse::RecDescent::_trace(q{>>Accepted scored production<<}, "", + q{VIEW}, + $tracelevel) + if defined $::RD_TRACE; + $return = $score_return; + } + splice @{$thisparser->{errors}}, $err_at; + $return = $item[$#item] unless defined $return; + if (defined $::RD_TRACE) + { + Parse::RecDescent::_trace(q{>>Matched rule<< (return value: [} . + $return . q{])}, "", + q{VIEW}, + $tracelevel); + Parse::RecDescent::_trace(q{(consumed: [} . + Parse::RecDescent::_tracemax(substr($_[1],0,-length($text))) . q{])}, + Parse::RecDescent::_tracefirst($text), + , q{VIEW}, + $tracelevel) + } + $_[1] = $text; + return $return; +} +} +package SQL::Translator::Grammar::SQLite; sub new { my $self = bless( { + '_AUTOTREE' => undef, + 'localvars' => '', + 'startcode' => '', + '_check' => { + 'thisoffset' => '', + 'itempos' => '', + 'prevoffset' => '', + 'prevline' => '', + 'prevcolumn' => '', + 'thiscolumn' => '' + }, + 'namespace' => 'Parse::RecDescent::SQL::Translator::Grammar::SQLite', + '_AUTOACTION' => undef, + 'rules' => { + 'WORD' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '\\w+', + 'hashname' => '__PATTERN1__', + 'description' => '/\\\\w+/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 388, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'WORD', + 'vars' => '', + 'line' => 388 + }, 'Parse::RecDescent::Rule' ), + 'statement_body' => bless( { + 'impcount' => 0, + 'calls' => [ + 'string', + 'nonstring' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'string', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 319 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'nonstring', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 319 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 319 + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'statement_body', + 'vars' => '', + 'line' => 319 + }, 'Parse::RecDescent::Rule' ), + 'for_each' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'FOR EACH ROW', + 'hashname' => '__PATTERN1__', + 'description' => '/FOR EACH ROW/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 310, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'for_each', + 'vars' => '', + 'line' => 310 + }, 'Parse::RecDescent::Rule' ), + 'column_def' => bless( { + 'impcount' => 0, + 'calls' => [ + 'comment', + 'NAME', + 'type', + 'column_constraint' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'comment', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 100000000, + 'matchrule' => 0, + 'repspec' => 's?', + 'lookahead' => 0, + 'line' => 123 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'NAME', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 123 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'type', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 123 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'column_constraint', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 100000000, + 'matchrule' => 0, + 'repspec' => 's?', + 'lookahead' => 0, + 'line' => 123 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 124, + 'code' => '{ + my $column = { + supertype => \'column\', + name => $item[2], + data_type => $item[3][0]->{\'type\'}, + size => $item[3][0]->{\'size\'}, + is_nullable => 1, + is_primary_key => 0, + is_unique => 0, + check => \'\', + default => undef, + constraints => $item[4], + comments => $item[1], + }; + + + for my $c ( @{ $item[4] } ) { + if ( $c->{\'type\'} eq \'not_null\' ) { + $column->{\'is_nullable\'} = 0; + } + elsif ( $c->{\'type\'} eq \'primary_key\' ) { + $column->{\'is_primary_key\'} = 1; + } + elsif ( $c->{\'type\'} eq \'unique\' ) { + $column->{\'is_unique\'} = 1; + } + elsif ( $c->{\'type\'} eq \'check\' ) { + $column->{\'check\'} = $c->{\'expression\'}; + } + elsif ( $c->{\'type\'} eq \'default\' ) { + $column->{\'default\'} = $c->{\'value\'}; + } + } + + $column; + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'column_def', + 'vars' => '', + 'line' => 123 + }, 'Parse::RecDescent::Rule' ), + 'constraint_def' => bless( { + 'impcount' => 0, + 'calls' => [ + 'PRIMARY_KEY', + 'parens_field_list', + 'conflict_clause', + 'UNIQUE', + 'CHECK_C', + 'expr' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'PRIMARY_KEY', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 210 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'parens_field_list', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 210 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 210 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 211, + 'code' => '{ + $return = { + supertype => \'constraint\', + type => \'primary_key\', + columns => $item[2], + on_conflict => $item[3][0], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'UNIQUE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 220 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'parens_field_list', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 220 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 220 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 221, + 'code' => '{ + $return = { + supertype => \'constraint\', + type => \'unique\', + columns => $item[2], + on_conflict => $item[3][0], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 219 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '2', + 'strcount' => 2, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'CHECK_C', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 230 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'pattern' => '(', + 'hashname' => '__STRING1__', + 'description' => '\'(\'', + 'lookahead' => 0, + 'line' => 230 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'subrule' => 'expr', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 230 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'pattern' => ')', + 'hashname' => '__STRING2__', + 'description' => '\')\'', + 'lookahead' => 0, + 'line' => 230 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 230 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 231, + 'code' => '{ + $return = { + supertype => \'constraint\', + type => \'check\', + expression => $item[3], + on_conflict => $item[5][0], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 229 + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'constraint_def', + 'vars' => '', + 'line' => 210 + }, 'Parse::RecDescent::Rule' ), + 'string' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '\'(\\\\.|\'\'|[^\\\\\\\'])*\'', + 'hashname' => '__PATTERN1__', + 'description' => '/\'(\\\\\\\\.|\'\'|[^\\\\\\\\\\\\\'])*\'/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 315, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'string', + 'vars' => '', + 'line' => 314 + }, 'Parse::RecDescent::Rule' ), + 'conflict_algorigthm' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '(rollback|abort|fail|ignore|replace)', + 'hashname' => '__PATTERN1__', + 'description' => '/(rollback|abort|fail|ignore|replace)/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 252, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'conflict_algorigthm', + 'vars' => '', + 'line' => 252 + }, 'Parse::RecDescent::Rule' ), + 'INDEX' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'index', + 'hashname' => '__PATTERN1__', + 'description' => '/index/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 368, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'INDEX', + 'vars' => '', + 'line' => 368 + }, 'Parse::RecDescent::Rule' ), + 'view_drop' => bless( { + 'impcount' => 0, + 'calls' => [ + 'VIEW', + 'if_exists', + 'view_name' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'VIEW', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 54 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'if_exists', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 54 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'view_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 54 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'view_drop', + 'vars' => '', + 'line' => 54 + }, 'Parse::RecDescent::Rule' ), + 'statement' => bless( { + 'impcount' => 0, + 'calls' => [ + 'begin_transaction', + 'commit', + 'drop', + 'comment', + 'create' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'begin_transaction', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 39 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'commit', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 40 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 40 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '2', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'drop', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 41 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 41 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '3', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'comment', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 42 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 42 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '4', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'create', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 43 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 43 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '5', + 'strcount' => 0, + 'dircount' => 1, + 'uncommit' => 0, + 'error' => 1, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'msg' => '', + 'hashname' => '__DIRECTIVE1__', + 'commitonly' => '', + 'lookahead' => 0, + 'line' => 44 + }, 'Parse::RecDescent::Error' ) + ], + 'line' => 44 + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'statement', + 'vars' => '', + 'line' => 39 + }, 'Parse::RecDescent::Rule' ), + 'field_name' => bless( { + 'impcount' => 0, + 'calls' => [ + 'NAME' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'NAME', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 248 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'field_name', + 'vars' => '', + 'line' => 248 + }, 'Parse::RecDescent::Rule' ), + 'eofile' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '^\\Z', + 'hashname' => '__PATTERN1__', + 'description' => '/^\\\\Z/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 37, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'eofile', + 'vars' => '', + 'line' => 37 + }, 'Parse::RecDescent::Rule' ), + 'startrule' => bless( { + 'impcount' => 0, + 'calls' => [ + 'statement', + 'eofile' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'statement', + 'expected' => undef, + 'min' => 1, + 'argcode' => undef, + 'max' => 100000000, + 'matchrule' => 0, + 'repspec' => 's', + 'lookahead' => 0, + 'line' => 29 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'eofile', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 29 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 29, + 'code' => '{ + $return = { + tables => \\%tables, + views => \\@views, + triggers => \\@triggers, + } +}' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'startrule', + 'vars' => '', + 'line' => 28 + }, 'Parse::RecDescent::Rule' ), + 'TRANSACTION' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'transaction', + 'hashname' => '__PATTERN1__', + 'description' => '/transaction/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 360, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'TRANSACTION', + 'vars' => '', + 'line' => 360 + }, 'Parse::RecDescent::Rule' ), + 'VALUE' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '[-+]?\\.?\\d+(?:[eE]\\d+)?', + 'hashname' => '__PATTERN1__', + 'description' => '/[-+]?\\\\.?\\\\d+(?:[eE]\\\\d+)?/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 398, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 399, + 'code' => '{ $item[1] }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '\'.*?\'', + 'hashname' => '__PATTERN1__', + 'description' => '/\'.*?\'/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 400, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 401, + 'code' => '{ + # remove leading/trailing quotes + my $val = $item[1]; + $val =~ s/^[\'"]|[\'"]$//g; + $return = $val; + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 400 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '2', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => 'NULL', + 'hashname' => '__PATTERN1__', + 'description' => '/NULL/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 407, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 408, + 'code' => '{ \'NULL\' }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 407 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '3', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => 'CURRENT_TIMESTAMP', + 'hashname' => '__PATTERN1__', + 'description' => '/CURRENT_TIMESTAMP/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 409, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 410, + 'code' => '{ \'CURRENT_TIMESTAMP\' }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 409 + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'VALUE', + 'vars' => '', + 'line' => 398 + }, 'Parse::RecDescent::Rule' ), + 'END_C' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'end', + 'hashname' => '__PATTERN1__', + 'description' => '/end/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 358, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'END_C', + 'vars' => '', + 'line' => 358 + }, 'Parse::RecDescent::Rule' ), + 'sort_order' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '(ASC|DESC)', + 'hashname' => '__PATTERN1__', + 'description' => '/(ASC|DESC)/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 264, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'sort_order', + 'vars' => '', + 'line' => 264 + }, 'Parse::RecDescent::Rule' ), + 'before_or_after' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '(before|after)', + 'hashname' => '__PATTERN1__', + 'description' => '/(before|after)/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 326, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 326, + 'code' => '{ $return = lc $1 }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'before_or_after', + 'vars' => '', + 'line' => 326 + }, 'Parse::RecDescent::Rule' ), + 'tbl_drop' => bless( { + 'impcount' => 0, + 'calls' => [ + 'TABLE', + 'table_name' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 1, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'TABLE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 52 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__DIRECTIVE1__', + 'name' => '', + 'lookahead' => 0, + 'line' => 52, + 'code' => '$commit = 1' + }, 'Parse::RecDescent::Directive' ), + bless( { + 'subrule' => 'table_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 52 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'tbl_drop', + 'vars' => '', + 'line' => 52 + }, 'Parse::RecDescent::Rule' ), + 'trg_drop' => bless( { + 'impcount' => 0, + 'calls' => [ + 'TRIGGER', + 'if_exists', + 'trigger_name' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'TRIGGER', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 56 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'if_exists', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 56 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'trigger_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 56 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'trg_drop', + 'vars' => '', + 'line' => 56 + }, 'Parse::RecDescent::Rule' ), + '_alternation_1_of_production_1_of_rule_drop' => bless( { + 'impcount' => 0, + 'calls' => [ + 'tbl_drop', + 'view_drop', + 'trg_drop' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'tbl_drop', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 411 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'view_drop', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 411 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 411 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '2', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'trg_drop', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 411 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 411 + }, 'Parse::RecDescent::Production' ) + ], + 'name' => '_alternation_1_of_production_1_of_rule_drop', + 'vars' => '', + 'line' => 411 + }, 'Parse::RecDescent::Rule' ), + 'view_name' => bless( { + 'impcount' => 0, + 'calls' => [ + 'qualified_name' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'qualified_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 332 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'view_name', + 'vars' => '', + 'line' => 332 + }, 'Parse::RecDescent::Rule' ), + 'parens_value_list' => bless( { + 'impcount' => 0, + 'calls' => [ + 'VALUE' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 2, + 'dircount' => 1, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'op' => [], + 'items' => [ + bless( { + 'pattern' => '(', + 'hashname' => '__STRING1__', + 'description' => '\'(\'', + 'lookahead' => 0, + 'line' => 259 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'expected' => '', + 'min' => 1, + 'name' => '\'VALUE(s)\'', + 'max' => 100000000, + 'leftarg' => bless( { + 'subrule' => 'VALUE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 259 + }, 'Parse::RecDescent::Subrule' ), + 'rightarg' => bless( { + 'subrule' => 'VALUE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 259 + }, 'Parse::RecDescent::Subrule' ), + 'hashname' => '__DIRECTIVE1__', + 'type' => 'leftop', + 'op' => bless( { + 'pattern' => ',', + 'hashname' => '__PATTERN1__', + 'description' => '/,/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 259, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + }, 'Parse::RecDescent::Operator' ), + bless( { + 'pattern' => ')', + 'hashname' => '__STRING2__', + 'description' => '\')\'', + 'lookahead' => 0, + 'line' => 259 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 260, + 'code' => '{ $item[2] }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'parens_value_list', + 'vars' => '', + 'line' => 259 + }, 'Parse::RecDescent::Rule' ), + 'commit' => bless( { + 'impcount' => 0, + 'calls' => [ + 'SEMICOLON' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'commit', + 'hashname' => '__PATTERN1__', + 'description' => '/commit/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 48, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 48 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'commit', + 'vars' => '', + 'line' => 48 + }, 'Parse::RecDescent::Rule' ), + 'CHECK_C' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'check', + 'hashname' => '__PATTERN1__', + 'description' => '/check/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 374, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'CHECK_C', + 'vars' => '', + 'line' => 374 + }, 'Parse::RecDescent::Rule' ), + 'SELECT' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'select', + 'hashname' => '__PATTERN1__', + 'description' => '/select/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 382, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'SELECT', + 'vars' => '', + 'line' => 382 + }, 'Parse::RecDescent::Rule' ), + 'trigger_step' => bless( { + 'impcount' => 0, + 'calls' => [ + 'statement_body', + 'SEMICOLON' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '(select|delete|insert|update)', + 'hashname' => '__PATTERN1__', + 'description' => '/(select|delete|insert|update)/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 321, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'subrule' => 'statement_body', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 100000000, + 'matchrule' => 0, + 'repspec' => 's?', + 'lookahead' => 0, + 'line' => 321 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 321 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 322, + 'code' => '{ + $return = join( \' \', $item[1], join \' \', @{ $item[2] || [] } ) + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'trigger_step', + 'vars' => '', + 'line' => 321 + }, 'Parse::RecDescent::Rule' ), + 'table_name' => bless( { + 'impcount' => 0, + 'calls' => [ + 'qualified_name' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'qualified_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 240 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'table_name', + 'vars' => '', + 'line' => 240 + }, 'Parse::RecDescent::Rule' ), + 'type' => bless( { + 'impcount' => 0, + 'calls' => [ + 'WORD', + 'parens_value_list' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'WORD', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 161 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'parens_value_list', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 161 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 162, + 'code' => '{ + $return = { + type => $item[1], + size => $item[2][0], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'type', + 'vars' => '', + 'line' => 161 + }, 'Parse::RecDescent::Rule' ), + 'NOT_NULL' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'not null', + 'hashname' => '__PATTERN1__', + 'description' => '/not null/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 370, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'NOT_NULL', + 'vars' => '', + 'line' => 370 + }, 'Parse::RecDescent::Rule' ), + 'TABLE' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'table', + 'hashname' => '__PATTERN1__', + 'description' => '/table/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 366, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'TABLE', + 'vars' => '', + 'line' => 366 + }, 'Parse::RecDescent::Rule' ), + 'trigger_name' => bless( { + 'impcount' => 0, + 'calls' => [ + 'qualified_name' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'qualified_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 334 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'trigger_name', + 'vars' => '', + 'line' => 334 + }, 'Parse::RecDescent::Rule' ), + 'instead_of' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'instead of', + 'hashname' => '__PATTERN1__', + 'description' => '/instead of/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 328, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'instead_of', + 'vars' => '', + 'line' => 328 + }, 'Parse::RecDescent::Rule' ), + 'drop' => bless( { + 'impcount' => 1, + 'calls' => [ + '_alternation_1_of_production_1_of_rule_drop', + 'SEMICOLON' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'drop', + 'hashname' => '__PATTERN1__', + 'description' => '/drop/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 50, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'subrule' => '_alternation_1_of_production_1_of_rule_drop', + 'matchrule' => 0, + 'implicit' => 'tbl_drop, or view_drop, or trg_drop', + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 50 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 50 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'drop', + 'vars' => '', + 'line' => 50 + }, 'Parse::RecDescent::Rule' ), + 'WHEN' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'when', + 'hashname' => '__PATTERN1__', + 'description' => '/when/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 390, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'WHEN', + 'vars' => '', + 'line' => 390 + }, 'Parse::RecDescent::Rule' ), + 'TEMPORARY' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => 'temp(orary)?', + 'hashname' => '__PATTERN1__', + 'description' => '/temp(orary)?/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 364, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 364, + 'code' => '{ 1 }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'TEMPORARY', + 'vars' => '', + 'line' => 364 + }, 'Parse::RecDescent::Rule' ), + 'database_event' => bless( { + 'impcount' => 0, + 'calls' => [ + 'column_list' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '(delete|insert|update)', + 'hashname' => '__PATTERN1__', + 'description' => '/(delete|insert|update)/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 297, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'update of', + 'hashname' => '__PATTERN1__', + 'description' => '/update of/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 299, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'subrule' => 'column_list', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 299 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'database_event', + 'vars' => '', + 'line' => 297 + }, 'Parse::RecDescent::Rule' ), + 'definition' => bless( { + 'impcount' => 0, + 'calls' => [ + 'constraint_def', + 'column_def' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'constraint_def', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 121 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'subrule' => 'column_def', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 121 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => 121 + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'definition', + 'vars' => '', + 'line' => 121 + }, 'Parse::RecDescent::Rule' ), + 'UNIQUE' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => 'unique', + 'hashname' => '__PATTERN1__', + 'description' => '/unique/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 392, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 392, + 'code' => '{ 1 }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'UNIQUE', + 'vars' => '', + 'line' => 392 + }, 'Parse::RecDescent::Rule' ), + 'expr' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '[^)]+', + 'hashname' => '__PATTERN1__', + 'description' => '/[^)]+/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 262, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'expr', + 'vars' => '', + 'line' => 262 + }, 'Parse::RecDescent::Rule' ), + 'AS' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'as', + 'hashname' => '__PATTERN1__', + 'description' => '/as/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 386, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'AS', + 'vars' => '', + 'line' => 386 + }, 'Parse::RecDescent::Rule' ), + 'column_constraint' => bless( { + 'impcount' => 0, + 'calls' => [ + 'NOT_NULL', + 'conflict_clause', + 'PRIMARY_KEY', + 'sort_order', + 'UNIQUE', + 'CHECK_C', + 'expr', + 'DEFAULT', + 'VALUE' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'NOT_NULL', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 169 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 169 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 170, + 'code' => '{ + $return = { + type => \'not_null\', + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'PRIMARY_KEY', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 176 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'sort_order', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 176 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 176 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 177, + 'code' => '{ + $return = { + type => \'primary_key\', + sort_order => $item[2][0], + on_conflict => $item[2][0], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 175 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '2', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'UNIQUE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 185 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 185 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 186, + 'code' => '{ + $return = { + type => \'unique\', + on_conflict => $item[2][0], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 184 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '3', + 'strcount' => 2, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'CHECK_C', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 193 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'pattern' => '(', + 'hashname' => '__STRING1__', + 'description' => '\'(\'', + 'lookahead' => 0, + 'line' => 193 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'subrule' => 'expr', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 193 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'pattern' => ')', + 'hashname' => '__STRING2__', + 'description' => '\')\'', + 'lookahead' => 0, + 'line' => 193 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 193 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 194, + 'code' => '{ + $return = { + type => \'check\', + expression => $item[3], + on_conflict => $item[5][0], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 192 + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '4', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'DEFAULT', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 202 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'VALUE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 202 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 203, + 'code' => '{ + $return = { + type => \'default\', + value => $item[2], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => 201 + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'column_constraint', + 'vars' => '', + 'line' => 169 + }, 'Parse::RecDescent::Rule' ), + 'conflict_clause' => bless( { + 'impcount' => 0, + 'calls' => [ + 'conflict_algorigthm' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'on conflict', + 'hashname' => '__PATTERN1__', + 'description' => '/on conflict/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 250, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'subrule' => 'conflict_algorigthm', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 250 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'conflict_clause', + 'vars' => '', + 'line' => 250 + }, 'Parse::RecDescent::Rule' ), + 'trigger_action' => bless( { + 'impcount' => 0, + 'calls' => [ + 'for_each', + 'when', + 'BEGIN_C', + 'trigger_step', + 'END_C' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'for_each', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 301 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'when', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 301 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'BEGIN_C', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 301 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'trigger_step', + 'expected' => undef, + 'min' => 1, + 'argcode' => undef, + 'max' => 100000000, + 'matchrule' => 0, + 'repspec' => 's', + 'lookahead' => 0, + 'line' => 301 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'END_C', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 301 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 302, + 'code' => '{ + $return = { + for_each => $item[1][0], + when => $item[2][0], + steps => $item[4], + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'trigger_action', + 'vars' => '', + 'line' => 301 + }, 'Parse::RecDescent::Rule' ), + 'nonstring' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => '[^;\\\'"]+', + 'hashname' => '__PATTERN1__', + 'description' => '/[^;\\\\\'"]+/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 317, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'nonstring', + 'vars' => '', + 'line' => 317 + }, 'Parse::RecDescent::Rule' ), + 'column_list' => bless( { + 'impcount' => 0, + 'calls' => [ + 'field_name' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 1, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'op' => [], + 'items' => [ + bless( { + 'expected' => '', + 'min' => 1, + 'name' => '\'field_name(s)\'', + 'max' => 100000000, + 'leftarg' => bless( { + 'subrule' => 'field_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 257 + }, 'Parse::RecDescent::Subrule' ), + 'rightarg' => bless( { + 'subrule' => 'field_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 257 + }, 'Parse::RecDescent::Subrule' ), + 'hashname' => '__DIRECTIVE1__', + 'type' => 'leftop', + 'op' => bless( { + 'pattern' => ',', + 'hashname' => '__PATTERN1__', + 'description' => '/,/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 257, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + }, 'Parse::RecDescent::Operator' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'column_list', + 'vars' => '', + 'line' => 257 + }, 'Parse::RecDescent::Rule' ), + 'SEMICOLON' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 1, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => ';', + 'hashname' => '__STRING1__', + 'description' => '\';\'', + 'lookahead' => 0, + 'line' => 394 + }, 'Parse::RecDescent::Literal' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'SEMICOLON', + 'vars' => '', + 'line' => 394 + }, 'Parse::RecDescent::Rule' ), + 'create' => bless( { + 'impcount' => 0, + 'calls' => [ + 'CREATE', + 'TEMPORARY', + 'UNIQUE', + 'INDEX', + 'WORD', + 'ON', + 'table_name', + 'parens_field_list', + 'conflict_clause', + 'SEMICOLON', + 'TABLE', + 'definition', + 'TRIGGER', + 'NAME', + 'before_or_after', + 'database_event', + 'trigger_action', + 'instead_of', + 'view_name', + 'VIEW', + 'AS', + 'select_statement' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'CREATE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'TEMPORARY', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'UNIQUE', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'INDEX', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'WORD', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'ON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'table_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'parens_field_list', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'conflict_clause', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 76 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 77, + 'code' => '{ + my $db_name = $item[7]->{\'db_name\'} || \'\'; + my $table_name = $item[7]->{\'name\'}; + + my $index = { + name => $item[5], + columns => $item[8], + on_conflict => $item[9][0], + is_temporary => $item[2][0] ? 1 : 0, + }; + + my $is_unique = $item[3][0]; + + if ( $is_unique ) { + $index->{\'type\'} = \'unique\'; + push @{ $tables{ $table_name }{\'constraints\'} }, $index; + } + else { + push @{ $tables{ $table_name }{\'indices\'} }, $index; + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 2, + 'dircount' => 1, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'op' => [], + 'items' => [ + bless( { + 'subrule' => 'CREATE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'TEMPORARY', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'TABLE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'table_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'pattern' => '(', + 'hashname' => '__STRING1__', + 'description' => '\'(\'', + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'expected' => '', + 'min' => 1, + 'name' => '\'definition(s)\'', + 'max' => 100000000, + 'leftarg' => bless( { + 'subrule' => 'definition', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Subrule' ), + 'rightarg' => bless( { + 'subrule' => 'definition', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Subrule' ), + 'hashname' => '__DIRECTIVE1__', + 'type' => 'leftop', + 'op' => bless( { + 'pattern' => ',', + 'hashname' => '__PATTERN1__', + 'description' => '/,/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 102, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + }, 'Parse::RecDescent::Operator' ), + bless( { + 'pattern' => ')', + 'hashname' => '__STRING2__', + 'description' => '\')\'', + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 102 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 103, + 'code' => '{ + my $db_name = $item[4]->{\'db_name\'} || \'\'; + my $table_name = $item[4]->{\'name\'}; + + $tables{ $table_name }{\'name\'} = $table_name; + $tables{ $table_name }{\'is_temporary\'} = $item[2][0] ? 1 : 0; + $tables{ $table_name }{\'order\'} = ++$table_order; + + for my $def ( @{ $item[6] } ) { + if ( $def->{\'supertype\'} eq \'column\' ) { + push @{ $tables{ $table_name }{\'columns\'} }, $def; + } + elsif ( $def->{\'supertype\'} eq \'constraint\' ) { + push @{ $tables{ $table_name }{\'constraints\'} }, $def; + } + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '2', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'CREATE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'TEMPORARY', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'TRIGGER', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'NAME', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'before_or_after', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'database_event', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'ON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'table_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'trigger_action', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 269 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 270, + 'code' => '{ + my $table_name = $item[8]->{\'name\'}; + push @triggers, { + name => $item[4], + is_temporary => $item[2][0] ? 1 : 0, + when => $item[5][0], + instead_of => 0, + db_events => [ $item[6] ], + action => $item[9], + on_table => $table_name, + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '3', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'CREATE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'TEMPORARY', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'TRIGGER', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'NAME', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'instead_of', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'database_event', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'ON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'view_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'trigger_action', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 283 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 284, + 'code' => '{ + my $table_name = $item[8]->{\'name\'}; + push @triggers, { + name => $item[4], + is_temporary => $item[2][0] ? 1 : 0, + when => undef, + instead_of => 1, + db_events => [ $item[6] ], + action => $item[9], + on_table => $table_name, + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '4', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'CREATE', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 339 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'TEMPORARY', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 339 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'VIEW', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 339 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'view_name', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 339 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'AS', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 339 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'select_statement', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 339 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 340, + 'code' => '{ + push @views, { + name => $item[4]->{\'name\'}, + sql => $item[6], + is_temporary => $item[2][0] ? 1 : 0, + } + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'create', + 'vars' => '', + 'line' => 75 + }, 'Parse::RecDescent::Rule' ), + 'when' => bless( { + 'impcount' => 0, + 'calls' => [ + 'WHEN', + 'expr' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'WHEN', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 312 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'subrule' => 'expr', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 312 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 312, + 'code' => '{ $item[2] }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'when', + 'vars' => '', + 'line' => 312 + }, 'Parse::RecDescent::Rule' ), + 'NAME' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '\'?(\\w+)\'?', + 'hashname' => '__PATTERN1__', + 'description' => '/\'?(\\\\w+)\'?/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 396, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 396, + 'code' => '{ $return = $1 }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'NAME', + 'vars' => '', + 'line' => 396 + }, 'Parse::RecDescent::Rule' ), + 'ON' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'on', + 'hashname' => '__PATTERN1__', + 'description' => '/on/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 384, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'ON', + 'vars' => '', + 'line' => 384 + }, 'Parse::RecDescent::Rule' ), + 'DEFAULT' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'default', + 'hashname' => '__PATTERN1__', + 'description' => '/default/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 376, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'DEFAULT', + 'vars' => '', + 'line' => 376 + }, 'Parse::RecDescent::Rule' ), + 'begin_transaction' => bless( { + 'impcount' => 0, + 'calls' => [ + 'TRANSACTION', + 'SEMICOLON' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'begin', + 'hashname' => '__PATTERN1__', + 'description' => '/begin/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 46, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'subrule' => 'TRANSACTION', + 'expected' => undef, + 'min' => 0, + 'argcode' => undef, + 'max' => 1, + 'matchrule' => 0, + 'repspec' => '?', + 'lookahead' => 0, + 'line' => 46 + }, 'Parse::RecDescent::Repetition' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 46 + }, 'Parse::RecDescent::Subrule' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'begin_transaction', + 'vars' => '', + 'line' => 46 + }, 'Parse::RecDescent::Rule' ), + 'TRIGGER' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'trigger', + 'hashname' => '__PATTERN1__', + 'description' => '/trigger/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 378, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'TRIGGER', + 'vars' => '', + 'line' => 378 + }, 'Parse::RecDescent::Rule' ), + 'select_statement' => bless( { + 'impcount' => 0, + 'calls' => [ + 'SELECT', + 'SEMICOLON' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'SELECT', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 348 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'pattern' => '[^;]+', + 'hashname' => '__PATTERN1__', + 'description' => '/[^;]+/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 348, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'subrule' => 'SEMICOLON', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 348 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 349, + 'code' => '{ + $return = join( \' \', $item[1], $item[2] ); + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'select_statement', + 'vars' => '', + 'line' => 348 + }, 'Parse::RecDescent::Rule' ), + 'if_exists' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'if exists', + 'hashname' => '__PATTERN1__', + 'description' => '/if exists/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 330, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'if_exists', + 'vars' => '', + 'line' => 330 + }, 'Parse::RecDescent::Rule' ), + 'PRIMARY_KEY' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'primary key', + 'hashname' => '__PATTERN1__', + 'description' => '/primary key/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 372, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'PRIMARY_KEY', + 'vars' => '', + 'line' => 372 + }, 'Parse::RecDescent::Rule' ), + 'CREATE' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'create', + 'hashname' => '__PATTERN1__', + 'description' => '/create/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 362, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'CREATE', + 'vars' => '', + 'line' => 362 + }, 'Parse::RecDescent::Rule' ), + 'comment' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '^\\s*(?:#|-{2}).*\\n', + 'hashname' => '__PATTERN1__', + 'description' => '/^\\\\s*(?:#|-\\{2\\}).*\\\\n/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 58, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 59, + 'code' => '{ + my $comment = $item[1]; + $comment =~ s/^\\s*(#|-{2})\\s*//; + $comment =~ s/\\s*$//; + $return = $comment; + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 3, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '\\/\\*', + 'hashname' => '__PATTERN1__', + 'description' => '/\\\\/\\\\*/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 66, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'pattern' => '[^\\*]+', + 'hashname' => '__PATTERN2__', + 'description' => '/[^\\\\*]+/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 66, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'pattern' => '\\*\\/', + 'hashname' => '__PATTERN3__', + 'description' => '/\\\\*\\\\//', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 66, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 67, + 'code' => '{ + my $comment = $item[2]; + $comment =~ s/^\\s*|\\s*$//g; + $return = $comment; + }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'comment', + 'vars' => '', + 'line' => 58 + }, 'Parse::RecDescent::Rule' ), + 'BEGIN_C' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'begin', + 'hashname' => '__PATTERN1__', + 'description' => '/begin/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 356, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'BEGIN_C', + 'vars' => '', + 'line' => 355 + }, 'Parse::RecDescent::Rule' ), + 'qualified_name' => bless( { + 'impcount' => 0, + 'calls' => [ + 'NAME' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'subrule' => 'NAME', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 242 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 243, + 'code' => '{ $return = { name => $item[1] } }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ), + bless( { + 'number' => '1', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '(\\w+)\\.(\\w+)', + 'hashname' => '__PATTERN1__', + 'description' => '/(\\\\w+)\\\\.(\\\\w+)/', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 245, + 'mod' => '', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 246, + 'code' => '{ $return = { db_name => $1, name => $2 } }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'qualified_name', + 'vars' => '', + 'line' => 242 + }, 'Parse::RecDescent::Rule' ), + 'parens_field_list' => bless( { + 'impcount' => 0, + 'calls' => [ + 'column_list' + ], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 2, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 0, + 'actcount' => 1, + 'items' => [ + bless( { + 'pattern' => '(', + 'hashname' => '__STRING1__', + 'description' => '\'(\'', + 'lookahead' => 0, + 'line' => 254 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'subrule' => 'column_list', + 'matchrule' => 0, + 'implicit' => undef, + 'argcode' => undef, + 'lookahead' => 0, + 'line' => 254 + }, 'Parse::RecDescent::Subrule' ), + bless( { + 'pattern' => ')', + 'hashname' => '__STRING2__', + 'description' => '\')\'', + 'lookahead' => 0, + 'line' => 254 + }, 'Parse::RecDescent::Literal' ), + bless( { + 'hashname' => '__ACTION1__', + 'lookahead' => 0, + 'line' => 255, + 'code' => '{ $item[2] }' + }, 'Parse::RecDescent::Action' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'parens_field_list', + 'vars' => '', + 'line' => 254 + }, 'Parse::RecDescent::Rule' ), + 'VIEW' => bless( { + 'impcount' => 0, + 'calls' => [], + 'changed' => 0, + 'opcount' => 0, + 'prods' => [ + bless( { + 'number' => '0', + 'strcount' => 0, + 'dircount' => 0, + 'uncommit' => undef, + 'error' => undef, + 'patcount' => 1, + 'actcount' => 0, + 'items' => [ + bless( { + 'pattern' => 'view', + 'hashname' => '__PATTERN1__', + 'description' => '/view/i', + 'lookahead' => 0, + 'rdelim' => '/', + 'line' => 380, + 'mod' => 'i', + 'ldelim' => '/' + }, 'Parse::RecDescent::Token' ) + ], + 'line' => undef + }, 'Parse::RecDescent::Production' ) + ], + 'name' => 'VIEW', + 'vars' => '', + 'line' => 380 + }, 'Parse::RecDescent::Rule' ) + } + }, 'Parse::RecDescent' ); +} + +=head1 AUTHOR + +Ken Y. Clark Ekclark@cpan.orgE. +