--- /dev/null
+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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [string]>>},
+ 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{<<Didn't match subrule: [nonstring]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match repeated subrule: [comment]>>},
+ 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{<<Didn't match subrule: [NAME]>>},
+ 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{<<Didn't match repeated subrule: [type]>>},
+ 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{<<Didn't match repeated subrule: [column_constraint]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [PRIMARY_KEY]>>},
+ 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{<<Didn't match subrule: [parens_field_list]>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [UNIQUE]>>},
+ 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{<<Didn't match subrule: [parens_field_list]>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [CHECK_C]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [expr]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [VIEW]>>},
+ 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{<<Didn't match repeated subrule: [if_exists]>>},
+ 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{<<Didn't match subrule: [view_name]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [begin_transaction]>>},
+ 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{<<Didn't match subrule: [commit]>>},
+ 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{<<Didn't match subrule: [drop]>>},
+ 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{<<Didn't match subrule: [comment]>>},
+ 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{<<Didn't match subrule: [create]>>},
+ 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: [<error...>]},
+ 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: [<error...>]},
+ 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{<<Didn't match directive>>},
+ Parse::RecDescent::_tracefirst($text))
+ if defined $::RD_TRACE;
+ }
+
+ last unless defined $_tok;
+ push @item, $item{__DIRECTIVE1__}=$_tok;
+
+
+
+ Parse::RecDescent::_trace(q{>>Matched production: [<error...>]<<},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [NAME]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match repeated subrule: [statement]>>},
+ 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{<<Didn't match subrule: [eofile]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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 <commit> 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{<<Didn't match subrule: [TABLE]>>},
+ 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: [<commit>]},
+ 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{<<Didn't match directive>>},
+ 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{<<Didn't match subrule: [table_name]>>},
+ 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 <commit> 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [TRIGGER]>>},
+ 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{<<Didn't match repeated subrule: [if_exists]>>},
+ 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{<<Didn't match subrule: [trigger_name]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [tbl_drop]>>},
+ 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{<<Didn't match subrule: [view_drop]>>},
+ 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{<<Didn't match subrule: [trg_drop]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [qualified_name]>>},
+ 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{<<Didn't match rule>>},
+ 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: ['(' <leftop: VALUE /,/ VALUE> ')']},
+ 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{<<Didn't match terminal>>},
+ 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: [<leftop: VALUE /,/ VALUE>]},
+ Parse::RecDescent::_tracefirst($text),
+ q{parens_value_list},
+ $tracelevel)
+ if defined $::RD_TRACE;
+ $expectation->is(q{<leftop: VALUE /,/ VALUE>})->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{<<Didn't match subrule: [VALUE]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [VALUE]>>},
+ 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{<<Didn't match operator: [<leftop: VALUE /,/ VALUE>]>>},
+ Parse::RecDescent::_tracefirst($text),
+ q{parens_value_list},
+ $tracelevel)
+ if defined $::RD_TRACE;
+ $expectation->failed();
+ last;
+ }
+ Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: VALUE /,/ VALUE>]<< (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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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: ['(' <leftop: VALUE /,/ VALUE> ')']<<},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match repeated subrule: [statement_body]>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [qualified_name]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [WORD]>>},
+ 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{<<Didn't match repeated subrule: [parens_value_list]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [qualified_name]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [_alternation_1_of_production_1_of_rule_drop]>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [column_list]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [constraint_def]>>},
+ 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{<<Didn't match subrule: [column_def]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [NOT_NULL]>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [PRIMARY_KEY]>>},
+ 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{<<Didn't match repeated subrule: [sort_order]>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [UNIQUE]>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [CHECK_C]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [expr]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [DEFAULT]>>},
+ 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{<<Didn't match subrule: [VALUE]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [conflict_algorigthm]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match repeated subrule: [for_each]>>},
+ 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{<<Didn't match repeated subrule: [when]>>},
+ 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{<<Didn't match subrule: [BEGIN_C]>>},
+ 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{<<Didn't match repeated subrule: [trigger_step]>>},
+ 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{<<Didn't match subrule: [END_C]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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: [<leftop: field_name /,/ field_name>]},
+ 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: [<leftop: field_name /,/ field_name>]},
+ 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{<<Didn't match subrule: [field_name]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [field_name]>>},
+ 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{<<Didn't match operator: [<leftop: field_name /,/ field_name>]>>},
+ Parse::RecDescent::_tracefirst($text),
+ q{column_list},
+ $tracelevel)
+ if defined $::RD_TRACE;
+ $expectation->failed();
+ last;
+ }
+ Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: field_name /,/ field_name>]<< (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: [<leftop: field_name /,/ field_name>]<<},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [CREATE]>>},
+ 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{<<Didn't match repeated subrule: [TEMPORARY]>>},
+ 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{<<Didn't match repeated subrule: [UNIQUE]>>},
+ 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{<<Didn't match subrule: [INDEX]>>},
+ 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{<<Didn't match subrule: [WORD]>>},
+ 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{<<Didn't match subrule: [ON]>>},
+ 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{<<Didn't match subrule: [table_name]>>},
+ 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{<<Didn't match subrule: [parens_field_list]>>},
+ 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{<<Didn't match repeated subrule: [conflict_clause]>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match action>> (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 '(' <leftop: definition /,/ definition> ')' 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{<<Didn't match subrule: [CREATE]>>},
+ 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{<<Didn't match repeated subrule: [TEMPORARY]>>},
+ 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{<<Didn't match subrule: [TABLE]>>},
+ 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{<<Didn't match subrule: [table_name]>>},
+ 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{<<Didn't match terminal>>},
+ 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: [<leftop: definition /,/ definition>]},
+ Parse::RecDescent::_tracefirst($text),
+ q{create},
+ $tracelevel)
+ if defined $::RD_TRACE;
+ $expectation->is(q{<leftop: definition /,/ definition>})->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{<<Didn't match subrule: [definition]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [definition]>>},
+ 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{<<Didn't match operator: [<leftop: definition /,/ definition>]>>},
+ Parse::RecDescent::_tracefirst($text),
+ q{create},
+ $tracelevel)
+ if defined $::RD_TRACE;
+ $expectation->failed();
+ last;
+ }
+ Parse::RecDescent::_trace(q{>>Matched operator: [<leftop: definition /,/ definition>]<< (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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match action>> (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 '(' <leftop: definition /,/ definition> ')' 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{<<Didn't match subrule: [CREATE]>>},
+ 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{<<Didn't match repeated subrule: [TEMPORARY]>>},
+ 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{<<Didn't match subrule: [TRIGGER]>>},
+ 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{<<Didn't match subrule: [NAME]>>},
+ 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{<<Didn't match repeated subrule: [before_or_after]>>},
+ 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{<<Didn't match subrule: [database_event]>>},
+ 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{<<Didn't match subrule: [ON]>>},
+ 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{<<Didn't match subrule: [table_name]>>},
+ 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{<<Didn't match subrule: [trigger_action]>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [CREATE]>>},
+ 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{<<Didn't match repeated subrule: [TEMPORARY]>>},
+ 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{<<Didn't match subrule: [TRIGGER]>>},
+ 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{<<Didn't match subrule: [NAME]>>},
+ 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{<<Didn't match subrule: [instead_of]>>},
+ 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{<<Didn't match subrule: [database_event]>>},
+ 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{<<Didn't match subrule: [ON]>>},
+ 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{<<Didn't match subrule: [view_name]>>},
+ 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{<<Didn't match subrule: [trigger_action]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match subrule: [CREATE]>>},
+ 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{<<Didn't match repeated subrule: [TEMPORARY]>>},
+ 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{<<Didn't match subrule: [VIEW]>>},
+ 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{<<Didn't match subrule: [view_name]>>},
+ 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{<<Didn't match subrule: [AS]>>},
+ 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{<<Didn't match subrule: [select_statement]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [WHEN]>>},
+ 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{<<Didn't match subrule: [expr]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match repeated subrule: [TRANSACTION]>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [SELECT]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [SEMICOLON]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match terminal>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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{<<Didn't match subrule: [NAME]>>},
+ 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{<<Didn't match action>> (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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match subrule: [column_list]>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match action>> (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{<<Didn't match rule>>},
+ 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{<<Didn't match terminal>>},
+ 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{<<Didn't match rule>>},
+ 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' => '<commit>',
+ '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' => '<leftop: VALUE /,/ VALUE>',
+ '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' => '<leftop: field_name /,/ field_name>',
+ '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' => '<leftop: definition /,/ definition>',
+ '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 E<lt>kclark@cpan.orgE<gt>.
+
projects / dbsrgits/SQL-Translator-2.0-ish.git / commitdiff