/*
* Copyright (c) 1997, 2008, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code 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
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* The Original Code is HAT. The Initial Developer of the
* Original Code is Bill Foote, with contributions from others
* at JavaSoft/Sun.
*/
package com.sun.tools.hat.internal.oql;
import com.sun.tools.hat.internal.model.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
/**
* This is Object Query Language Interpreter
*
*/
public class OQLEngine {
static {
try {
// Do we have javax.script support?
// create ScriptEngineManager
Class<?> managerClass = Class.forName("javax.script.ScriptEngineManager");
Object manager = managerClass.newInstance();
// create JavaScript engine
Method getEngineMethod = managerClass.getMethod("getEngineByName",
new Class[] { String.class });
Object jse = getEngineMethod.invoke(manager, new Object[] {"js"});
oqlSupported = (jse != null);
} catch (Exception exp) {
oqlSupported = false;
}
}
// check OQL is supported or not before creating OQLEngine
public static boolean isOQLSupported() {
return oqlSupported;
}
public OQLEngine(Snapshot snapshot) {
if (!isOQLSupported()) {
throw new UnsupportedOperationException("OQL not supported");
}
init(snapshot);
}
/**
Query is of the form
select <java script code to select>
[ from [instanceof] <class name> [<identifier>]
[ where <java script boolean expression> ]
]
*/
public synchronized void executeQuery(String query, ObjectVisitor visitor)
throws OQLException {
debugPrint("query : " + query);
StringTokenizer st = new StringTokenizer(query);
if (st.hasMoreTokens()) {
String first = st.nextToken();
if (! first.equals("select") ) {
// Query does not start with 'select' keyword.
// Just treat it as plain JavaScript and eval it.
try {
Object res = evalScript(query);
visitor.visit(res);
} catch (Exception e) {
throw new OQLException(e);
}
return;
}
} else {
throw new OQLException("query syntax error: no 'select' clause");
}
String selectExpr = "";
boolean seenFrom = false;
while (st.hasMoreTokens()) {
String tok = st.nextToken();
if (tok.equals("from")) {
seenFrom = true;
break;
}
selectExpr += " " + tok;
}
if (selectExpr.equals("")) {
throw new OQLException("query syntax error: 'select' expression can not be empty");
}
String className = null;
boolean isInstanceOf = false;
String whereExpr = null;
String identifier = null;
if (seenFrom) {
if (st.hasMoreTokens()) {
String tmp = st.nextToken();
if (tmp.equals("instanceof")) {
isInstanceOf = true;
if (! st.hasMoreTokens()) {
throw new OQLException("no class name after 'instanceof'");
}
className = st.nextToken();
} else {
className = tmp;
}
} else {
throw new OQLException("query syntax error: class name must follow 'from'");
}
if (st.hasMoreTokens()) {
identifier = st.nextToken();
if (identifier.equals("where")) {
throw new OQLException("query syntax error: identifier should follow class name");
}
if (st.hasMoreTokens()) {
String tmp = st.nextToken();
if (! tmp.equals("where")) {
throw new OQLException("query syntax error: 'where' clause expected after 'from' clause");
}
whereExpr = "";
while (st.hasMoreTokens()) {
whereExpr += " " + st.nextToken();
}
if (whereExpr.equals("")) {
throw new OQLException("query syntax error: 'where' clause cannot have empty expression");
}
}
} else {
throw new OQLException("query syntax error: identifier should follow class name");
}
}
executeQuery(new OQLQuery(selectExpr, isInstanceOf, className,
identifier, whereExpr), visitor);
}
private void executeQuery(OQLQuery q, ObjectVisitor visitor)
throws OQLException {
JavaClass clazz = null;
if (q.className != null) {
clazz = snapshot.findClass(q.className);
if (clazz == null) {
throw new OQLException(q.className + " is not found!");
}
}
StringBuffer buf = new StringBuffer();
buf.append("function __select__(");
if (q.identifier != null) {
buf.append(q.identifier);
}
buf.append(") { return ");
buf.append(q.selectExpr.replace('\n', ' '));
buf.append("; }");
String selectCode = buf.toString();
debugPrint(selectCode);
String whereCode = null;
if (q.whereExpr != null) {
buf = new StringBuffer();
buf.append("function __where__(");
buf.append(q.identifier);
buf.append(") { return ");
buf.append(q.whereExpr.replace('\n', ' '));
buf.append("; }");
whereCode = buf.toString();
}
debugPrint(whereCode);
// compile select expression and where condition
try {
evalMethod.invoke(engine, new Object[] { selectCode });
if (whereCode != null) {
evalMethod.invoke(engine, new Object[] { whereCode });
}
if (q.className != null) {
Enumeration objects = clazz.getInstances(q.isInstanceOf);
while (objects.hasMoreElements()) {
JavaHeapObject obj = (JavaHeapObject) objects.nextElement();
Object[] args = new Object[] { wrapJavaObject(obj) };
boolean b = (whereCode == null);
if (!b) {
Object res = call("__where__", args);
if (res instanceof Boolean) {
b = ((Boolean)res).booleanValue();
} else if (res instanceof Number) {
b = ((Number)res).intValue() != 0;
} else {
b = (res != null);
}
}
if (b) {
Object select = call("__select__", args);
if (visitor.visit(select)) return;
}
}
} else {
// simple "select <expr>" query
Object select = call("__select__", new Object[] {});
visitor.visit(select);
}
} catch (Exception e) {
throw new OQLException(e);
}
}
public Object evalScript(String script) throws Exception {
return evalMethod.invoke(engine, new Object[] { script });
}
public Object wrapJavaObject(JavaHeapObject obj) throws Exception {
return call("wrapJavaObject", new Object[] { obj });
}
public Object toHtml(Object obj) throws Exception {
return call("toHtml", new Object[] { obj });
}
public Object call(String func, Object[] args) throws Exception {
return invokeMethod.invoke(engine, new Object[] { func, args });
}
private static void debugPrint(String msg) {
if (debug) System.out.println(msg);
}
private void init(Snapshot snapshot) throws RuntimeException {
this.snapshot = snapshot;
try {
// create ScriptEngineManager
Class<?> managerClass = Class.forName("javax.script.ScriptEngineManager");
Object manager = managerClass.newInstance();
// create JavaScript engine
Method getEngineMethod = managerClass.getMethod("getEngineByName",
new Class[] { String.class });
engine = getEngineMethod.invoke(manager, new Object[] {"js"});
// initialize engine with init file (hat.js)
InputStream strm = getInitStream();
Class<?> engineClass = Class.forName("javax.script.ScriptEngine");
evalMethod = engineClass.getMethod("eval",
new Class[] { Reader.class });
evalMethod.invoke(engine, new Object[] {new InputStreamReader(strm)});
// initialize ScriptEngine.eval(String) and
// Invocable.invokeFunction(String, Object[]) methods.
Class<?> invocableClass = Class.forName("javax.script.Invocable");
evalMethod = engineClass.getMethod("eval",
new Class[] { String.class });
invokeMethod = invocableClass.getMethod("invokeFunction",
new Class[] { String.class, Object[].class });
// initialize ScriptEngine.put(String, Object) method
Method putMethod = engineClass.getMethod("put",
new Class[] { String.class, Object.class });
// call ScriptEngine.put to initialize built-in heap object
putMethod.invoke(engine, new Object[] {
"heap", call("wrapHeapSnapshot", new Object[] { snapshot })
});
} catch (Exception e) {
if (debug) e.printStackTrace();
throw new RuntimeException(e);
}
}
private InputStream getInitStream() {
return getClass().getResourceAsStream("/com/sun/tools/hat/resources/hat.js");
}
private Object engine;
private Method evalMethod;
private Method invokeMethod;
private Snapshot snapshot;
private static boolean debug = false;
private static boolean oqlSupported;
}