Using TreSQL from Java

Simple Java interface for query is not implemented yet - we have not tried to process tree results from java. At the moment, there is a facade class for java - uniso.query.JavaQuery - but it defines just ids(...) and count(...) methods for very limited subset of queries. Java facade sample on that facade for some web application, including initialization and logging code, is shown here:

package uniso.myapp;

import java.sql.Connection;
import java.util.*;

import javax.naming.*;
import javax.sql.DataSource;

import org.apache.log4j.LogManager;
import org.apache.log4j.Logger;

import scala.Function0;
import scala.runtime.AbstractFunction2;
import scala.runtime.BoxedUnit;
import uniso.query.Env$;
import uniso.query.JavaQuery;
import uniso.query.metadata.JDBCMetaData;

public class MyQueryFacade {
    private static Logger logger = LogManager.getLogger(MyQueryFacade.class);
    private static final String TRESQL_LOGGING = "tresql.logging";
    private static final boolean loggingOn;

    static {
        Env$.MODULE$.update(JDBCMetaData.apply("MyDbName", "MySchemaName"));

        // maybe turn logging on
        String doLog = System.getProperty(TRESQL_LOGGING);
        if (doLog == null || doLog.trim().length() == 0) {
            try {
                Context ctx = new InitialContext();
                doLog = (String) ctx.lookup("java:/comp/env/" + TRESQL_LOGGING);
            } catch (NamingException nex) {
                nex.printStackTrace();
            }
        }
        loggingOn = "true".equalsIgnoreCase(doLog);
        if (loggingOn) {
            Env$.MODULE$.update(//
                    new AbstractFunction2<Function0<String>, Object, BoxedUnit>() {
                        @Override
                        public BoxedUnit apply(//
                                Function0<String> msg, Object level) {
                            logger.warn(msg.apply());
                            return BoxedUnit.UNIT;
                        }
                    });
        }
    }

    private static Map<String, Object> map(List<Object> pars) {
        Map<String, Object> map = new HashMap<String, Object>();
        int i = 0;
        for (Object par : pars) {
            i++;
            map.put("" + i, par);
        }
        return map;
    }

    public static List<Long> ids(String query, List<Object> pars) {
        return ids(query, map(pars));
    }

    public static List<Long> ids(String query, Map<String, Object> pars) {
        Connection conn = null;
        if (loggingOn) {
            log("query for ids", query, pars);
        }
        try {
            conn = connection();
            Env$.MODULE$.update(conn);
            List<Long> result = JavaQuery.ids(query, pars);
            return result;
        } catch (Exception ex) {
            String dbg = "\n" + query + "\n";
            throw new RuntimeException("Failed to get ids" + dbg, ex);
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (Exception ex) {
                    logger.warn("Failed to close connection", ex);
                }
            }
        }
    }

    public static Long count(String query, List<Object> pars) {
        return count(query, map(pars));
    }

    public static Long count(String query, Map<String, Object> pars) {
        Connection conn = null;
        if (loggingOn) {
            log("query for count", query, pars);
        }
        try {
            conn = connection();
            Env$.MODULE$.update(conn);
            Long result = JavaQuery.count(query, pars);
            return result;
        } catch (Exception ex) {
            String dbg = "\n" + query + "\n";
            throw new RuntimeException("Failed to get count" + dbg, ex);
        } finally {
            if (conn != null) {
                try {
                    conn.close();
                } catch (Exception ex) {
                    logger.warn("Failed to close connection", ex);
                }
            }
        }
    }

    private static String parString(Object par) {
        if (par instanceof Object[]) {
            StringBuilder buf = new StringBuilder();
            buf.append('[');
            for (Object value : (Object[]) par) {
                buf.append(parString(value)).append(',');
            }
            if (buf.length() > 1) {
                buf.setLength(buf.length() - 1);
            }
            buf.append(']');
            return buf.toString();
        } else if (par instanceof String) {
            return "'" + par + "'";
        } else {
            return String.valueOf(par);
        }
    }

    private static void log(String method, String query,
            Map<String, Object> pars) {
        StringBuilder msg = new StringBuilder();
        msg.append(method).append(": ").append(query);
        if (pars.size() > 0) {
            TreeMap<String, Object> sortedPars = new TreeMap<String, Object>();
            sortedPars.putAll(pars);
            msg.append('\n').append("  pars: ");
            for (Map.Entry<String, Object> e : sortedPars.entrySet()) {
                msg.append(parString(e.getKey())).append('=')
                        .append(parString(e.getValue())).append(", ");
            }
            msg.setLength(msg.length() - 2);
        }
        logger.warn(msg.toString());
    }

    static Connection connection() throws Exception {
        Context ctx = new InitialContext();
        DataSource ds = (DataSource) ctx.lookup("java:comp/env/jdbc/myapp");
        Connection conn = ds.getConnection();
        return conn;
    }
}