ossp-pkg/quos/TODO
1.10
- how to implement dynamically adjusting views based
on total number of result records??
- sqlite with_v3=yes
perl
perl-dbi with_dbd_sqlite=yes
perl-www
perl-xml
perl-util
apache
- apache.conf:
Alias /quos/ /u/rse/wrk/ossp/quos/
<Directory /u/hms/wrk/ossp/quos/>
Options +ExecCGI
</Directory>
- prepare:
- purpose of all files
- OpenPKG RDF as example
- perldoc IO::File
- perldoc CGI
- perldoc String::Divert
- perldoc DBI
- design for HTML form for boolean expression based query!
(RT, perldoc DBIx::SearchBuilder)
- UI Query Part (boolean expression to HTML form):
Boolean Expression:
expr ::= field op value
| "!" expr
| expr "||" expr
| expr "&&" expr
| "(" expr ")"
field ::= /^[A-Z]+$/
op ::= "==" | "!=" | "<" | "<=" | ">" | ">=" | "=~" | "!~"
value ::= /^.*$/
HTML Form:
------------------------------
( field op value
& field op value )
& ( | field op value
& field op value
| ! field op value
& ! field op value )
------------------------------
<:NN V:NN UPDATE CLEAR SUBMIT
------------------------------
NAME LOAD DELETE
NAME SAVE HYPERLINK
------------------------------
- modules:
* transformation module:
- format 1: 2d form elements (input after submit of web form)
lo2 lo1 lo0 fn fo fv
+---+ +---+ +---+ +---------+ +---+ +---------+
0 ...| | | | | | | grp | |== | | Mail |
+---+ +---+ +---+ +---------+ +---+ +---------+
+---+ +---+ +---+ +---------+ +---+ +---------+
1 ...| | | | ||| | | desc | |=~ | | \bMTA\b |
+---+ +---+ +---+ +---------+ +---+ +---------+
+---+ +---+ +---+ +---------+ +---+ +---------+
2 ...| | |&& | | | | class | |== | | CORE |
+---+ +---+ +---+ +---------+ +---+ +---------+
+---+ +---+ +---+ +---------+ +---+ +---------+
3 ...| | | | ||| | | class | |== | | BASE |
+---+ +---+ +---+ +---------+ +---+ +---------+
: : : : : :
fn-0="grp"&fo-0="=="&fv-0="Mail"&lo0-1="||"&fn-1="desc"&fo-1="=~"&fv-1="\bMTA\b"
lo1-2="&&"&fn-2="class"&fo-2="=="&fv-2="CORE"&lo0-3="||"&fn-3="class"&fo-3="=="&fv-3="BASE"
- format 2a: astract syntax tree for query expression (internal representation)
function-style:
AND( OR( EQ(grp,"Mail"),
RE(desc,"\bMTA\b") ),
OR( EQ(class,"CORE"),
EQ(class,"BASE") ) )
in-core-style:
my $expr =
[ "AND", [ "OR", [ "EQ", "grp", "Mail" ],
[ "RE", "desc", "\bMTA\b"] ],
[ "OR", [ "EQ", "class", "CORE" ],
[ "EQ", "class", "BASE" ] ] ];
"print $expr->[2]->[1]->[2];" -> "CORE"
my $format2b = &transform_tree($expr, \&transform_style_perl);
my $format2c = &transform_tree($expr, \&transform_style_sql);
sub transform_tree {
my ($expr, $style) = @_;
my $str = '';
my ($op, $a1, $a2) = @{$expr};
$op = &style($op);
$a1 = ref($a1) ? &style(&transform_tree($a1, $style)) : &style($a1);
$a2 = ref($a2) ? &style(&transform_tree($a2, $style)) : &style($a2);
$str = "$a1 $op $a2";
return $str;
}
sub transform_style_perl {
my ($token) = @_;
$token =~ s/^AND$/&&/;
$token =~ s/^OR$/||/;
$token =~ s/^EQ$/==/;
$token =~ s/^RE$/=~/;
return $token;
}
sub transform_style_sql {
my ($token) = @_;
$token =~ s/^EQ$/=/;
$token =~ s/^RE$/MATCH/;
return $token;
}
- format 2b: C-style query expression (input after hyperlink in web page)
(grp == "Mail" || desc =~ "\bMTA\b") &&
(class == "CORE || class == "BASE")
- format 2c: SQL-style query expression (output for database query)
(quos.q_grp = 'Mail' OR quos.q_desc MATCH? '\bMTA\b') AND
(quos.q_class = 'CORE' OR quos.q_class = 'BASE')
* creation of web formular (render query)
sub_render_form (cgi-Object | expression, row, column
- Parsing CFG:
OSSP shiela (with tricks)
OSSP ac (uses Parse::RecDescent)
Parse::RecDescent (full featured recursive-descend parsing)
GENERAL:
config ::= directive(s)
directive ::= word arg ";"
arg ::= "{" config "}"
| word
word ::= m/"[^"]*"/
| m/'[^']*'/
| m/[^\s+;]+/
SPECIAL:
config ::= directive(s)
directive ::= options
| queries
| views
options ::= "option" "{" options-directive(s) "}" ";"
options-directive ::= webpage
| database
webpage ::= "webpage" word word ";"
database ::= "database" "{" database-directive(s) "}" ";"
database-directive ::= ...
...
queries ::= group(s)
...
views ::= view(s)
...
word ::= m/"[^"]*"/
| m/'[^']*'/
| m/[^\s+;]+/
- Parsing RDF:
my $str = ...; # string representation
my $rdf = {}; # AST representation
$str =~ s/<Repository([^>]+)>(.+?)<\/Repository>/&do_repository($rdf, $1, $2)/sge;
sub do_repository {
my ($rdf, $attr, $str) = @_;
my ($name) = ($attr =~ m/rdf:resource="([^"]+)"/s);
$rdf->{$name} = {};
$str =~ s/<rdf:Description([^>]+)>(.+?)<\/rdf:Description>/&do_destription($rdf->{$name}, $1, $2)/sge;
sub do_description {
my ($rdf, $attr, $str) = @_;
$rdf->{...} = ...;
}
}
1. geht nur, wenn die Sprache keine rekursiven Elemente enthält, d.h. ein
Element kann nicht in sich selber (in beliebiger Tiefe) vorkommen
(Hinweis: Für Compilerbauer uninteressant)
2. Blockstruktur der Sprache wird direkt Substitution+Funktionsaufruf umgesetzt
3. Auf jeder Ebene wird die bereits erkannte Information in einer internen
Datenstruktur aufgesammelt ($rdf)
