the lucene index was always recreated and never closed

h2/src/main/org/h2/api/CloseListener.java

+/*
+ * Copyright 2004-2008 H2 Group. Multiple-Licensed under the H2 License, 
+ * Version 1.0, and under the Eclipse Public License, Version 1.0
+ * (http://h2database.com/html/license.html).
+ * Initial Developer: H2 Group
+ */
+package org.h2.api;
+
+import java.sql.SQLException;
+
+/**
+ * A trigger that implements this interface will be notified when the database
+ * is closed.
+ */
+public interface CloseListener {
+    
+    /**
+     * This method is called when the database is closed.
+     * If the method throws an exception, it will be logged, but
+     * closing the database will continue.
+     * 
+     * @throws SQLException
+     */
+    void close() throws SQLException;
+
+}

h2/src/main/org/h2/api/Trigger.java

@@ -63,5 +63,5 @@ public interface Trigger {
      *             if the operation must be undone
      */
     void fire(Connection conn, Object[] oldRow, Object[] newRow) throws SQLException;
-
+    
 }

h2/src/main/org/h2/engine/Database.java

@@ -34,6 +34,7 @@ import org.h2.result.SearchRow;
 import org.h2.schema.Schema;
 import org.h2.schema.SchemaObject;
 import org.h2.schema.Sequence;
+import org.h2.schema.TriggerObject;
 import org.h2.store.DataHandler;
 import org.h2.store.DataPage;
 import org.h2.store.DiskFile;
@@ -1043,6 +1044,11 @@ public class Database implements DataHandler {
                     Sequence sequence = (Sequence) sequences.get(i);
                     sequence.close();
                 }
+                ObjectArray triggers = getAllSchemaObjects(DbObject.TRIGGER);
+                for (int i = 0; i < triggers.size(); i++) {
+                    TriggerObject trigger = (TriggerObject) triggers.get(i);
+                    trigger.close();
+                }
                 meta.close(systemSession);
                 systemSession.commit(true);                
                 indexSummaryValid = true;

h2/src/main/org/h2/engine/FunctionAlias.java

@@ -18,21 +18,22 @@ import org.h2.message.Message;
 import org.h2.message.Trace;
 import org.h2.table.Table;
 import org.h2.util.ClassUtils;
+import org.h2.util.ObjectArray;
 import org.h2.value.DataType;
 import org.h2.value.Value;
 import org.h2.value.ValueNull;
 
 /**
  * Represents a user-defined function, or alias.
+ * 
+ * @author Thomas Mueller
+ * @author Gary Tong
  */
 public class FunctionAlias extends DbObjectBase {
-
-    private boolean hasConnectionParam;
+    
     private String className;
     private String methodName;
-    private Method javaMethod;
-    private int paramCount;
-    private int dataType;
+    private JavaMethod[] javaMethods; 
 
     public FunctionAlias(Database db, int id, String name, String javaClassMethod, boolean force) throws SQLException {
         initDbObjectBase(db, id, name, Trace.FUNCTION);
@@ -55,38 +56,38 @@ public class FunctionAlias extends DbObjectBase {
     }
 
     private synchronized void load() throws SQLException {
-        if (javaMethod != null) {
+        if (javaMethods != null) {
             return;
         }
         Class javaClass = ClassUtils.loadUserClass(className);
         Method[] methods = javaClass.getMethods();
+        ObjectArray list = new ObjectArray();
         for (int i = 0; i < methods.length; i++) {
             Method m = methods[i];
             if (!Modifier.isStatic(m.getModifiers())) {
                 continue;
             }
-            if (m.getName().equals(methodName)) {
-                javaMethod = m;
-                break;
-            } else if (getMethodSignature(m).equals(methodName)) {
-                javaMethod = m;
-                break;
+            if (m.getName().equals(methodName) || getMethodSignature(m).equals(methodName)) {
+                JavaMethod javaMethod = new JavaMethod(m);
+                for (int j = 0; j < list.size(); j++) {
+                    JavaMethod old = (JavaMethod) list.get(j);
+                    if (old.paramCount == javaMethod.paramCount) {
+                        throw Message.getSQLException(ErrorCode.METHODS_MUST_HAVE_DIFFERENT_PARAMETER_COUNTS_2, 
+                                new String[] {
+                                    old.method.toString(),
+                                    javaMethod.method.toString()
+                                }
+                        );
+                    }
+                }
+                list.add(javaMethod);
             }
         }
-        if (javaMethod == null) {
+        if (list.size() == 0) {
             throw Message.getSQLException(ErrorCode.METHOD_NOT_FOUND_1, methodName + " (" + className + ")");
         }
-        Class[] paramClasses = javaMethod.getParameterTypes();
-        paramCount = paramClasses.length;
-        if (paramCount > 0) {
-            Class paramClass = paramClasses[0];
-            if (Connection.class.isAssignableFrom(paramClass)) {
-                hasConnectionParam = true;
-                paramCount--;
-            }
-        }
-        Class returnClass = javaMethod.getReturnType();
-        dataType = DataType.getTypeFromClass(returnClass);
+        javaMethods = new JavaMethod[list.size()];
+        list.toArray(javaMethods);
     }
 
     private String getMethodSignature(Method m) {
@@ -110,15 +111,6 @@ public class FunctionAlias extends DbObjectBase {
         return buff.toString();
     }
 
-    public Class[] getColumnClasses() throws SQLException {
-        load();
-        return javaMethod.getParameterTypes();
-    }
-
-    public int getDataType() {
-        return dataType;
-    }
-
     public String getCreateSQLForCopy(Table table, String quotedName) {
         throw Message.getInternalError();
     }
@@ -144,7 +136,7 @@ public class FunctionAlias extends DbObjectBase {
         database.removeMeta(session, getId());
         className = null;
         methodName = null;
-        javaMethod = null;
+        javaMethods = null;
         invalidate();
     }
 
@@ -153,69 +145,20 @@ public class FunctionAlias extends DbObjectBase {
     }
 
     /**
-     * Call the user-defined function and return the value.
+     * Find the Java method that matches the arguments.
      * 
-     * @param session the session
      * @param args the argument list
-     * @param columnList true if the function should only return the column list
-     * @return the value
+     * @return the Java method
+     * @throws SQLException if no matching method could be found
      */
-    public synchronized Value getValue(Session session, Expression[] args, boolean columnList) throws SQLException {
+    public JavaMethod findJavaMethod(Expression[] args) throws SQLException {
         load();
-        Class[] paramClasses = javaMethod.getParameterTypes();
-        Object[] params = new Object[paramClasses.length];
-        int p = 0;
-        if (hasConnectionParam && params.length > 0) {
-            params[p++] = session.createConnection(columnList);
-        }
-        for (int a = 0; a < args.length && p < params.length; a++, p++) {
-            Class paramClass = paramClasses[p];
-            int type = DataType.getTypeFromClass(paramClass);
-            Value v = args[a].getValue(session);
-            v = v.convertTo(type);
-            Object o = v.getObject();
-            if (o == null) {
-                if (paramClass.isPrimitive()) {
-                    if (columnList) {
-                        // if the column list is requested, the parameters may
-                        // be null
-                        // need to set to default value otherwise the function
-                        // can't be called at all
-                        o = DataType.getDefaultForPrimitiveType(paramClass);
-                    } else {
-                        // NULL for a java primitive: return NULL
-                        return ValueNull.INSTANCE;
-                    }
-                }
-            } else {
-                if (!paramClass.isAssignableFrom(o.getClass()) && !paramClass.isPrimitive()) {
-                    o = DataType.convertTo(session, session.createConnection(false), v, paramClass);
-                }
-            }
-            params[p] = o;
-        }
-        boolean old = session.getAutoCommit();
-        try {
-            session.setAutoCommit(false);
-            try {
-                Object returnValue;
-                returnValue = javaMethod.invoke(null, params);
-                if (returnValue == null) {
-                    return ValueNull.INSTANCE;
-                }
-                Value ret = DataType.convertToValue(session, returnValue, dataType);
-                return ret.convertTo(dataType);
-            } catch (Exception e) {
-                throw Message.convert(e);
+        for (int i = 0; i < javaMethods.length; i++) {
+            if (javaMethods[i].paramCount == args.length) {
+                return javaMethods[i];
             }
-        } finally {
-            session.setAutoCommit(old);
         }
-    }
-
-    public int getParameterCount() throws SQLException {
-        load();
-        return paramCount;
+        throw Message.getSQLException(ErrorCode.METHOD_NOT_FOUND_1, methodName + " (" + className + ")");
     }
 
     public String getJavaClassName() {
@@ -225,14 +168,124 @@ public class FunctionAlias extends DbObjectBase {
     public String getJavaMethodName() {
         return this.methodName;
     }
-
+    
     /**
-     * Check if this function requires a database connection.
+     * Get the Java methods mapped by this function.
      * 
-     * @return if the function requires a connection
+     * @return the Java methods.
      */
-    public boolean hasConnectionParam() {
-        return this.hasConnectionParam;
+    public JavaMethod[] getJavaMethods() throws SQLException {
+        load();
+        return javaMethods;
+    }
+    
+    /**
+     * There may be multiple Java methods that match a function name.
+     * Each method must have a different number of parameters however.
+     * This helper class represents one such method.
+     */
+    public static class JavaMethod {
+        Method method;
+        boolean hasConnectionParam;
+        int paramCount;
+        int dataType;
+
+        JavaMethod(Method method) throws SQLException {
+            this.method = method;
+            Class[] paramClasses = method.getParameterTypes();
+            paramCount = paramClasses.length;
+            if (paramCount > 0) {
+                Class paramClass = paramClasses[0];
+                if (Connection.class.isAssignableFrom(paramClass)) {
+                    hasConnectionParam = true;
+                    paramCount--;
+                }
+            }
+            Class returnClass = method.getReturnType();
+            dataType = DataType.getTypeFromClass(returnClass);
+        }
+        
+        /**
+         * Check if this function requires a database connection.
+         * 
+         * @return if the function requires a connection
+         */
+        public boolean hasConnectionParam() {
+            return this.hasConnectionParam;
+        }
+        
+        /**
+         * Call the user-defined function and return the value.
+         * 
+         * @param session the session
+         * @param args the argument list
+         * @param columnList true if the function should only return the column list
+         * @return the value
+         */
+        public Value getValue(Session session, Expression[] args, boolean columnList) throws SQLException {
+            Class[] paramClasses = method.getParameterTypes();
+            Object[] params = new Object[paramClasses.length];
+            int p = 0;
+            if (hasConnectionParam && params.length > 0) {
+                params[p++] = session.createConnection(columnList);
+            }
+            for (int a = 0; a < args.length && p < params.length; a++, p++) {
+                Class paramClass = paramClasses[p];
+                int type = DataType.getTypeFromClass(paramClass);
+                Value v = args[a].getValue(session);
+                v = v.convertTo(type);
+                Object o = v.getObject();
+                if (o == null) {
+                    if (paramClass.isPrimitive()) {
+                        if (columnList) {
+                            // if the column list is requested, the parameters may
+                            // be null
+                            // need to set to default value otherwise the function
+                            // can't be called at all
+                            o = DataType.getDefaultForPrimitiveType(paramClass);
+                        } else {
+                            // NULL for a java primitive: return NULL
+                            return ValueNull.INSTANCE;
+                        }
+                    }
+                } else {
+                    if (!paramClass.isAssignableFrom(o.getClass()) && !paramClass.isPrimitive()) {
+                        o = DataType.convertTo(session, session.createConnection(false), v, paramClass);
+                    }
+                }
+                params[p] = o;
+            }
+            boolean old = session.getAutoCommit();
+            try {
+                session.setAutoCommit(false);
+                try {
+                    Object returnValue;
+                    returnValue = method.invoke(null, params);
+                    if (returnValue == null) {
+                        return ValueNull.INSTANCE;
+                    }
+                    Value ret = DataType.convertToValue(session, returnValue, dataType);
+                    return ret.convertTo(dataType);
+                } catch (Exception e) {
+                    throw Message.convert(e);
+                }
+            } finally {
+                session.setAutoCommit(old);
+            }
+        }
+        
+        public Class[] getColumnClasses() throws SQLException {
+            return method.getParameterTypes();
+        }
+
+        public int getDataType() {
+            return dataType;
+        }
+        
+        public int getParameterCount() throws SQLException {
+            return paramCount;
+        }
+
     }
 
 }

h2/src/main/org/h2/fulltext/FullTextLucene.java

@@ -32,6 +32,7 @@ import org.apache.lucene.search.Hits;
 import org.apache.lucene.search.IndexSearcher;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.Searcher;
+import org.h2.api.CloseListener;
 import org.h2.api.Trigger;
 import org.h2.command.Parser;
 import org.h2.engine.Session;
@@ -50,7 +51,7 @@ import org.h2.util.StringUtils;
  */
 public class FullTextLucene extends FullText
 //## Java 1.4 begin ##
-implements Trigger
+implements Trigger, CloseListener
 //## Java 1.4 end ##
 {
 
@@ -574,8 +575,9 @@ implements Trigger
             synchronized (indexers) {
                 indexer = (IndexModifier) indexers.get(path);
                 if (indexer == null) {
-                    // TODO: create flag = true means re-create
-                    indexer = new IndexModifier(path, new StandardAnalyzer(), true);
+                    Analyzer analyzer = new StandardAnalyzer();
+                    boolean create = !IndexReader.indexExists(path);
+                    indexer = new IndexModifier(path, analyzer, create);
                     indexers.put(path, indexer);
                 }
             }
@@ -613,6 +615,18 @@ implements Trigger
             index[i] = found;
         }
     }
+    
+    public void close() throws SQLException {
+        try {
+            if (indexer != null) {
+                indexer.flush();
+                indexer.close();
+                indexer = null;
+            }
+        } catch (Exception e) {
+            throw convertException(e);
+        }
+    }
     //## Java 1.4 end ##
 
 }

h2/src/main/org/h2/schema/TriggerObject.java

@@ -9,6 +9,7 @@ package org.h2.schema;
 import java.sql.Connection;
 import java.sql.SQLException;
 
+import org.h2.api.CloseListener;
 import org.h2.api.Trigger;
 import org.h2.command.Parser;
 import org.h2.constant.ErrorCode;
@@ -313,7 +314,7 @@ public class TriggerObject extends SchemaObjectBase {
     }
 
     /**
-     * Get the trigger class name
+     * Get the trigger class name.
      * 
      * @return the class name
      */
@@ -321,4 +322,15 @@ public class TriggerObject extends SchemaObjectBase {
         return triggerClassName;
     }
 
+    /**
+     * Close the trigger.
+     */
+    public void close() throws SQLException {
+        if (triggerCallback != null) {
+            if (triggerCallback instanceof CloseListener) {
+                ((CloseListener) triggerCallback).close();
+            }
+        }
+    }
+
 }