Copyright © 2002 T. H. Merrett

COMP 612                Principles of Database Programming                Week 4

                                    jRelix

relix			current directory contains (will contain) database 
		NB use an empty directory or a directory with a relix DB.

  commands
    trace;              NB It's a toggle. Turning it on erases old .trace.
                          pr <rel>;
    sr;                   sr <rel>;
    sd;                   sd <dom>;
                          dr <rellist>;
                          dd <domlist>;
    srd;                  srd <rel>;
                          input "<unix path>";		NB no *, ~
    quit;


  declarations
    domain <ident> {bool ! intg ! real ! strg};
        << These are implemented with the corresponding Java types: >>
        <<4 bytes each for intg, real=float                         >>
    relation <ident> (<dom-list>) [<- {(<values>),(<values>),..} !
                                   <- "<unix path>"];
    e.g., relation R(b,i,s,r,g)<-{(true,1,-1,3.14,"hi")};


  domain algebra
   let <ident> be <horiz expr>;
   let <ident> be red <ass-com-op> of <dom expr>;
   let <ident> be equiv <ass-com-op> of <dom expr> by <dom-list>;
   let <ident> be fun <fun-par-op> of <dom expr> order <dom-list>;
   let <ident> be par <fun-par-op> of <dom expr> order <dom-list> by <dom-list>;

    <ass-com-op>::= + ! * ! & ! | ! max ! min
    <fun-par-op>::= <ass-com-op> ! - ! / ! mod ! ** ! cat ! pred ! succ !
    <horiz op>::= <fun-par-op but not pred, succ> ! < ! <= ! = ! >= ! > ! ~= !
                  if..then..else.. ! abs ! cos ! sin ! tan ! log10 ! log ! ln !
                  atan ! acos ! asin ! tanh ! cosh ! sinh ! isknown !
		  round ! ceil ! floor ! ord ! chr
                       (function arguments in parentheses, e.g., abs(A))

    <bool>::= true ! false ! dc ! dk        <<ascii rep. of true: 1; false: 0>>
    <intg>::= <digit>+ ! dc ! dk            <<ascii rep. of dc: ^E;  dk: ^B>>
    <strg>::= "<alphameric>+" ! dc ! dk     <<ascii rep. of end item: ^F>>
    <real>::= <digit>* . <digit>* E [+,-] <digit>+ ! dc ! dk 
   

  relational algebra
    <ident>             <-             <rel expr>;
    <ident>             <+             <rel expr>;
    <ident> [<dom-list> <- <dom-list>] <rel expr>;
    <ident> [<dom-list> <+ <dom-list>] <rel expr>;
    <ident> [initial <rel expr>] is <rel expr> [target {<rel expr> ! empty}];
    update <ident> <upd-op>;

    <rel expr>::= <ident> !
	     <rel expr> [<dom-list>:<join-op>:<dom-list>] <rel expr> !
             [# ! . ! [<dom-list>]] [quant (<#.dom-expr>)<dom>,..]
                                [where <dom expr>] in <rel expr> 
    <join-op> ::= <mu-join-op> ! <sigma-join-op> ! nop
    <mu-join-op>   ::=  ijoin  !  djoin ! ujoin ! sjoin ! ljoin ! rjoin ! drjoin !
                       natjoin ! dljoin 
    <sigma-join-op>::= gtjoin !  sup  ! eqjoin  !  sub  !  ltjoin !  sep  !
                               gejoin !          lejoin !          iejoin !
                                 div  !
                      ~gtjoin ! ~sup  ! ~eqjoin ! ~sub  ! ~ltjoin ! icomp !
   (<negation>::= not )                                        natcomp
   (<negation>::= ! )                                        natcomp

    <upd-op>::= add <rel expr> ! delete <rel expr> !
                change <ident> <- <dom-expr> ,.. !
                change <ident> <- <dom-expr> ,.. using <join-op> <rel expr>


These notes do not define a grammar; symbols are used variously as terminals and as metasymbols.