Rebar3 Plugin for xqerl

[zadean]

It would be really helpful to have a rebar3 plugin for compiling and running XQuery.

Possibly a good starting place for how to do it is: https://github.com/lfe-rebar3/rebar3_lfe

At a minimum, compile and run would be great to have. Though creating new projects would also be fantastic!! 🌟

[grantmacken]

What I work with at the moment is a few rather amateur utility escripts that make rpc calls to a running docker xq instance.

The build tool I use is make .

• compile.escript
  given a xquery file the script will attempt a compile and throw a vim 'error format' line if the compile failed
  This I mostly use for xquery library modules
  Since one library might depend up another I use make to resolve the dependency chain

• compile-run.escript
  arg 1: file name of the main module xquery
  arg 2: single json string passed to the query

An example query pattern for the main modules goes something like

declare variable $arg external;
declare variable $dbIO := QName("http://markup.nz/#err", 'dbIO');
try {
let $mArg := parse-json($arg)
let $uri := $mArg('uri')
return 
  if ( $uri => doc-available() ) 
  then ( $uri => doc() => serialize(map{''omit-xml-declaration': true() })" )
  else (error( $dbIO, ``[ item [ `{$uri` ] not found  ]``))
} catch * {
``[
  ERROR!
  module: `{$err:module}`
  line number: `{$err:line-number}`
 `{$err:code}`: `{$err:description}`

]``
}

I place my main modules in code/src in the docker instance.
So if I name the above as 'getDoc.xq' then
in a terminal bash script I can run it something like

 docker exec xq xqerl escript \
   bin/scripts/compile-run.escript \
   getDoc.xq \
  '{"uri": "http://markup.nz/holdings/DIV"}'

Obviously to be useful he uri will be a param in a function

[grantmacken]

My escripts are pretty basic as I have limited understanding of erlang.

Although you can use docker exec xq xqerl eval I start to explore running escrpts in the conrtainer.

• query.escript
  This simple basic escript takes a xquery string and and makes an rpc call to a running docker xq instance.

#!/usr/bin/env escript
%% -*- coding: utf-8 -*-
%%! -setcookie monster

main([ARG]) ->
    HOST = net_adm:localhost(),
    SELF_NODE = list_to_atom( "eman" ++ "@" ++ HOST),
    {ok, _} = net_kernel:start([SELF_NODE, longnames]),
    XQERL_NODE = list_to_atom(os:getenv("NAME")),
    R = rpc:call( XQERL_NODE,
                    xqerl,
                    run,
                   [ARG]), 
    io:format( [ R ] ).

I place my scripts in `bin/scripts in the docker instance

so now I can call simple xquery expressions
say in a bash script

function isDocAvailable() {
  docker exec xq xqerl escript bin/scripts/query.escript \
  "'$1' => doc-available() => string()"
}

function getDoc() {
  docker exec xq xqerl escript bin/scripts/query.escript \
    "'$1' => doc() => serialize(map{''omit-xml-declaration': true() })"
}

uri="http://markup.nz/holdings/DIV" 
if $( isDocAvailable $uri ) ;then
  getDoc $uri
fi

[zadean]

@grantmacken These are great! A really nice way to interact with a "living" xqerl instance!

[zadean]

A goal here is to be able to use xqerl as an imbedded dependency in Erlang or Elixir apps, and get feedback from the compiler or IDE right away.

Wouldn't it be cool to put a few *.xq files in the src or lib directory along side some *.erl or *.ex files??

Use XQuery directly in a BEAM app??

The thinking here is like using yecc or leex and being able to use the modules you just built..

Mind you, this will need a change in the way that xqerl compiles code. It will be an all-or-nothing compilation instead of a "living" system that has its own code server.
Maybe bake the typing info into the compile BEAM file??

Either way, something that lets you add XQuery code to a release, not only in runtime..
No need to pack an XQuery file into a gen_server and call from there...
Make the XQuery code a first-class citizen (whatever that means).