Metacat

import java.util.TreeSet;

import java.util.Vector;

/**

 * A Class that represents an XML element and its contents,

 * and can build itself from a database connection

 */

public class ElementNode extends BasicNode {

  /** 

   * Construct a new ElementNode instance, and recursively create its children

   *

    while (it.hasNext()) {

      NodeRecord currentNode = (NodeRecord)it.next();

      if (currentNode.nodeid == nodeid) {

                          " (" + currentNode.parentnodeid +

                          ", " + currentNode.nodeindex + 

        // Process the current node

        setNodeType(currentNode.nodetype);

        setNodeID(currentNode.nodeid);

      } else {

        // Process the children nodes

        if (currentNode.parentnodeid == getNodeID()) {

                          " (" + currentNode.parentnodeid +

                          ", " + currentNode.nodeindex + 

          if ((currentNode.nodetype).equals("ELEMENT")) {

            ElementNode child = new ElementNode(nodeRecordList,

                                                currentNode.nodeid);

            addChildNode(child);

          }

        } else {

                          " (" + currentNode.parentnodeid +

                          ", " + currentNode.nodeindex +

        }

      }

    }

import edu.ucsb.nceas.dbadapter.AbstractDatabase;

import org.xml.sax.Attributes;

import org.xml.sax.InputSource;

import org.xml.sax.SAXException;

    private StringBuffer textBuffer = new StringBuffer();

    /**

     * construct an instance of the QuerySpecification class

     *

            ownerQuery = ownerQuery + "lower(user_owner) ='" + userName + "'";

        }

        return ownerQuery;

    }

        String allowString = constructAllowString();

        allowQuery = "SELECT docid from xml_access WHERE( " + allowString;

        allowQuery = allowQuery + ") AND subtreeid IS NULL";

        return allowQuery;

    }

                }//if

            }//for

        }//if

        return allowQuery;

    }

        String denyString = constructDenyString();

        denyQuery = "SELECT docid from xml_access WHERE( " + denyString;

        denyQuery = denyQuery + ") AND subtreeid IS NULL ";

        return denyQuery;

    }

        accessQuery = " AND (docid IN(" + onwer + ")";

        accessQuery = accessQuery + " OR (docid IN (" + allow + ")"

                + " AND docid NOT IN (" + deny + ")))";

        return accessQuery;

    }

        // make sure if return fields has an attribute or not

        if (inputString.indexOf(ATTRIBUTESYMBOL) == -1) {

            // no attribute value will be returned

            returnFieldList.add(inputString);

            containsExtendedSQL = true;

        } else {

          if ( inputString.startsWith(ATTRIBUTESYMBOL) ) {

            // case where the return field is solely an attribute

            String returnPath = newPathExpressionWithOutAttribute(inputString);

            String attributeName = getAttributeName(inputString);

            Vector pathInfo = new Vector();

            // has a attribute return field

            // divied the return filed into two parts, one is path and the

            // other is attribue name

            String returnPath = newPathExpressionWithOutAttribute(inputString);

            String attributeName = getAttributeName(inputString);

            Vector pathInfo = new Vector();

        // if there is only one percentage search item, this query is a

        // percentage

        // search query

        if (query.getPercentageSymbolCount() == 1) {

            percentageSearch = true;

        }

        sql.append(")");

        sql.append(")");

        sql.append(")");

        return sql.toString();

    }

    public String printExtendedSQL(String doclist,

            Hashtable unaccessableNodePair)

    {

        StringBuffer self = new StringBuffer();

        boolean usePathIndex = true;

                self.append(" AND xml_nodes.rootnodeid = xml_documents.rootnodeid");

            }

            return self.toString();

        }

                    self.append(returnPath);

                    self.append("' AND ");

                }else {

                }

                self.append("xml_nodes.nodename like '");

                self.append(attributeName);

                    self.append(returnPath);

                    self.append("' AND ");

                }else {

                }

                self.append("xml_nodes.nodename like '");

                self.append(attributeName);

        self.append(") AND xml_nodes.docid in (");

        self.append(doclist);

        self.append(") AND xml_nodes.nodetype = 'ATTRIBUTE'");

        return self.toString();

    }

        if (index != 0) {

            newExpression = pathExpression.substring(0, index - 1);

        }

        return newExpression;

    }

        if (index != 1) {

            attributeName = path.substring(index + 1, size);

        }

        return attributeName;

    }

import javax.servlet.*;

import javax.servlet.http.*;

import org.xml.sax.*;

public class MetacatReplication extends HttpServlet implements Runnable

  private static final String TIMEREPLICATIONINTERVAl = "timedreplicationinterval";

  private static final String FIRSTTIME  = "firsttimedreplication";

  private static final int    TIMEINTERVALLIMIT = 7200000;

  /**

   * Initialize the servlet by creating appropriate database connections

   */

    try

    {

       timedReplicationIsOn = (new Boolean(util.getOption(TIMEREPLICATION ).trim())).booleanValue();

       timeInterval = (new Long(util.getOption(TIMEREPLICATIONINTERVAl).trim())).longValue();

       String firstTimeStr = util.getOption(FIRSTTIME);

       firstTime = ReplicationHandler.combinateCurrentDateAndGivenTime(firstTimeStr);

       // set up time replication if it is on

       if (timedReplicationIsOn)

       {

    {

        // the timed replication in Metacat.properties file has problem

        // so timed replication is setting to false;

                     " in Metacat replication servlet init because " +

        MetacatReplication.replErrorLog("Couldn't set up timed replication "+

                " in Metacat replication servlet init because " +

                e.getMessage());

          if (params.containsKey("sessionid")) 

          {

             sess_id = ((String[]) params.get("sessionid"))[0];

             if (sessionHash.containsKey(sess_id)) 

             {

                  sess = (HttpSession) sessionHash.get(sess_id);

             }

           } 

           username = (String) sess.getAttribute("username");

           groupnames = (String[]) sess.getAttribute("groupnames");

           if (!MetaCatUtil.isAdministrator(username, groupnames)) 

           {

                       "\" is not authorized for this action.");

               out.print("</error>");

               out.close();

               replErrorLog("The user \"" + username +

                       "\" is not authorized for this action: " +action);

               return;

      } else {

        timeInterval = TIMEINTERVALLIMIT ;

      }

      if ( params.containsKey("firsttime"))

      {

         firstTimeStr = ((String[])params.get("firsttime"))[0];

         try

         {

           firstTime = ReplicationHandler.combinateCurrentDateAndGivenTime(firstTimeStr);

         }

         catch (Exception e)

         {

            throw new ServletException(e.getMessage());

         }

      }

      else

      {

          MetacatReplication.replErrorLog("You should specify the first time " +

                                          "to start a time replication");

          return;

      }

      }//try

      catch (SQLException ee)

      {

                "MetacatReplication.handleServerControlRequest to close pstmt "

      }//catch

      finally

      {

        //override = true; //we are now overriding the default action

      }

      MetacatReplication.replLog("force replication request from " + server);

      // sending back read request to remote server

      URL u = new URL("https://" + server + "?server="

                +util.getLocalReplicationServerName()

      String homeServer=(String)docinfoHash.get("home_server");

      String createdDate = (String)docinfoHash.get("date_created");

      String updatedDate = (String)docinfoHash.get("date_updated");

      // Get Document type

      String docType = (String)docinfoHash.get("doctype");

      String parserBase = null;

      // this for eml2 and we need user eml2 parser

      if (docType != null &&

          (docType.trim()).equals(DocumentImpl.EML2_0_0NAMESPACE))

      {

         parserBase = DocumentImpl.EML200;

      }

      else if (docType != null && (docType.trim()).equals(DocumentImpl.EML2_0_1NAMESPACE))

      {

         parserBase = DocumentImpl.EML200;

      }

      else if (docType != null && (docType.trim()).equals(DocumentImpl.EML2_1_0NAMESPACE))

      {

         parserBase = DocumentImpl.EML210;

      }

      // Get DBConnection from pool

      dbConn=DBConnectionPool.

                                      " failed to added to DB with " +

                                      "action " + dbaction + " because "+

                                       e.getMessage());

    }//catch

    finally

  {

    MetacatReplication.replLog("force replication delete request from " + server);

    MetacatReplication.replLog("force replication delete docid " + docid);

    DocumentImpl.delete(docid, null, null, server);

    MetacatReplication.replLog("document " + docid + " was successfully deleted ");

  }

  catch(Exception e)

  {

    MetacatReplication.replErrorLog("document " + docid +

                                    " failed to delete because "+

                                     e.getMessage());

  }//catch

    // Make sure there is a docid and server

    if (docid==null || server==null || server.equals(""))

    {

      return;

    }

      }

      MetacatReplication.replLog("force replication request from " + server);

      // get the document info from server

      URL docinfourl = new URL("https://" + server +

                               "?server="+util.getLocalReplicationServerName()

      String createdDate = (String)docinfoHash.get("date_created");

      String updatedDate = (String)docinfoHash.get("date_updated");

                                      " failed to added to DB with " +

                                      "action " + dbaction + " because "+

                                       e.getMessage());

              ("ERROR in MetacatReplication.handleForceDataFileReplicate" +

    }

  }

  /**

    //check if the doicd is null

    if (docId==null)

    {

      return;

    }

      {

        //response.setContentType("text/xml");

        //outPut.println("<error>Couldn't pass the trust test</error>");

        return;

      }

    }//try

    }

    catch(Exception e)

    {

      //e.printStackTrace(System.out);

      response.setContentType("text/xml");

      out.println("<error>"+e.getMessage()+"</error>");

        docsql.append(serverLocation);

        revisionSql.append(serverLocation);

      }

      // Get any deleted documents

      delsql.append("select distinct docid from ");

      {

        delsql.append("and server_location = 1");

      }

      doclist.append(prepareRevisionDoc(dbConn,revisionSql.toString(),replicateData));

      doclist.append("</updates></replication>");

      pstmt.close();

      //conn.close();

      response.setContentType("text/xml");

    }

    catch(Exception e)

    {

      //e.printStackTrace(System.out);

      response.setContentType("text/xml");

      out.println("<error>"+e.getMessage()+"</error>");

      }//try

      catch (SQLException ee)

      {

      }//catch

      finally

      {

  private String prepareRevisionDoc(DBConnection dbConn, String revSql, 

                            boolean replicateData) throws Exception

  {

      StringBuffer revDocList = new StringBuffer();

      PreparedStatement pstmt = dbConn.prepareStatement(revSql);

      //usage count should increas 1

    catch(Exception e)

    {

      e.printStackTrace(System.out);

      if(printFlag)

      {

      }//try

      catch (SQLException ee)

      {

      }//catch

      finally

      {

  {

    try

    {

      Thread.sleep(30000); //the lock will expire in 30 seconds

                             (String)fileLocks.elementAt(fileLocks.size() - 1) +

      fileLocks.remove(fileLocks.size() - 1);

      //fileLocks is treated as a FIFO queue.  If there are more than one lock

    }

    catch(Exception e)

    {

    }

  }

      }//try

      catch (SQLException ee)

      {

      }//catch

      finally

      {

       }//try

       catch(Exception ee)

       {

       }//catch

       finally

      }

      catch (Exception ee)

      {

      }

      finally

      {

      }

      catch(Exception ee)

      {

      }

      finally

      {

  {

    char istreamChar;

    int istreamInt;

    InputStream input = u.openStream();

    InputStreamReader istream = new InputStreamReader(input);

    StringBuffer serverResponse = new StringBuffer();

    while((istreamInt = istream.read()) != -1)

      }//try

      catch(Exception ee)

      {

      }//catch

      finally

      {

import edu.ucsb.nceas.morpho.datapackage.Triple;

import edu.ucsb.nceas.morpho.datapackage.TripleCollection;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

import org.xml.sax.SAXParseException;

    public static final String ECOGRID = "ecogrid://";

    /**

     * Construct an instance of the handler class

     *

    /** SAX Handler that receives notification of beginning of the document */

    public void startDocument() throws SAXException

    {

        // Create the document node representation as root

        rootNode = new DBSAXNode(connection, this.docid);

    /** SAX Handler that receives notification of end of the document */

    public void endDocument() throws SAXException

    {

        // Starting new thread for writing XML Index.

        // It calls the run method of the thread.

                        connection, tripleList);

                }

            } catch (Exception e) {

                        "Failed to write triples into relation table"

                throw new SAXException(

                        "Failed to write triples into relation table "

                                + e.getMessage());

    public void startPrefixMapping(String prefix, String uri)

            throws SAXException

    {

        namespaces.put(prefix, uri);

    }

        // for element <eml:eml...> qname is "eml:eml", local name is "eml"

        // for element <acl....> both qname and local name is "eml"

        // uri is namesapce

        DBSAXNode parentNode = null;

        DBSAXNode currentNode = null;

                } else {

                    doctype = docname;

                }

            } else if (doctype == null) {

                // because docname is not null and it is declared in dtd

                // so could not be in schema, no namespace

                doctype = docname;

            }

            rootNode.writeNodename(docname);

    }

    public void runIndexingThread(){

        boolean useXMLIndex =

            (new Boolean(MetaCatUtil.getOption("usexmlindex"))).booleanValue();

        if (useXMLIndex && !isRevisionDoc) {

                xmlIndex.start();

            } catch (NullPointerException e) {

                xmlIndex = null;

            }

        }

    }

             currentDocument.buildIndex();

            }

        } catch (Exception e) {

        }

    }

                ResultSet doccheckRS = xmlDocCheck.getResultSet();

                boolean tableHasRows = doccheckRS.next();

                if (tableHasRows) {

                    inxmldoc = true;

                }

                doccheckRS.close();

                //dbconn.close();

            } catch (SQLException sqle) {

            }

        } finally {

            DBConnectionPool.returnDBConnection(dbConn, serialNumber);

    /** SAX Handler that is called for each XML text node */

    public void characters(char[] cbuf, int start, int len) throws SAXException

    {

        // buffer all text nodes for same element. This is for text was splited

        // into different nodes

        textBuffer.append(new String(cbuf, start, len));

        // if text buffer .size is greater than max, write it to db.

        // so we can save memory

        if (textBuffer.length() > MAXDATACHARS) {

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

        // When validation is turned "on", white spaces are reported here

        // When validation is turned "off" white spaces are not reported here,

        // but through characters() callback

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        String data = null;

    public void processingInstruction(String target, String data)

            throws SAXException

    {

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        endNodeId = currentNode.writeChildNodeToDB("PI", target, data, docid);

    }

    public void endElement(String uri, String localName, String qName)

            throws SAXException

    {

        // write buffered text nodes into db (so no splited)

        DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

        // into the buffer, write the buffer to data base. The reason we put

        // write database here is for xerces some time split text node

        if (hitTextNode) {

            endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                    currentNode);

        // we don't put the dtd node into node stack

        DBSAXNode dtdNode = new DBSAXNode(connection, name, publicId, systemId,

                currentNode, currentNode.getRootNodeID(), docid);

    }

    /**

    {

        processingDTD = false;

    }

    /**

     */

    public void comment(char[] ch, int start, int length) throws SAXException

    {

        if (!processingDTD) {

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            endNodeId = currentNode.writeChildNodeToDB("COMMENT", null,

     */

    public void startCDATA() throws SAXException

    {

    }

    /**

     */

    public void endCDATA() throws SAXException

    {

    }

    /**

     */

    public void startEntity(String name) throws SAXException

    {

        //System.out.println("start ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = true;

     */

    public void endEntity(String name) throws SAXException

    {

        //System.out.println("end ENTITY: " + name);

        if (name.equals("[dtd]")) {

            processingDTD = false;

            throws org.xml.sax.SAXException

    {

        //System.out.println("ELEMENTDECL: " + name + " " + model);

    }

    /**

        //System.out.println("ATTRIBUTEDECL: " + eName + " "

        //                        + aName + " " + type + " " + valueDefault + " "

        //                        + value);

    }

    /**

            throws org.xml.sax.SAXException

    {

        //System.out.println("INTERNENTITYDECL: " + name + " " + value);

    }

    /**

    {

        //System.out.println("EXTERNENTITYDECL: " + name + " " + publicId

        //                              + " " + systemId);

        // it processes other external entity, not the DTD;

        // it doesn't signal for the DTD here

        processingDTD = false;

     */

    public void fatalError(SAXParseException exception) throws SAXException

    {

        throw (new SAXException("Fatal processing error.", exception));

    }

     */

    public void error(SAXParseException exception) throws SAXException

    {

        throw (new SAXException("Error in processing EML.", exception));

    }

     */

    public void warning(SAXParseException exception) throws SAXException

    {

        throw (new SAXException("Warning.", exception));

    }

        // if there are some cotent in buffer, write it

        if (bufferSize > 0) {

            // This loop deals with the case where there are more characters

            // than can fit in a single database text field (limit is

            // MAXDATACHARS). If the text to be inserted exceeds MAXDATACHARS,

import java.util.Stack;

import java.util.Vector;

import org.xml.sax.Attributes;

import org.xml.sax.SAXException;

    private static final String DISTRIBUTION = "distribution";

    /**

     * Construct an instance of the handler class In this constructor, user can

     * specify the version need to upadate

        }

        catch (Exception e)

        {

            throw new SAXException(e.getMessage());

        }

    }

        // for element <eml:eml...> qname is "eml:eml", local name is "eml"

        // for element <acl....> both qname and local name is "eml"

        // uri is namesapce

        DBSAXNode parentNode = null;

        DBSAXNode currentNode = null;

                    } else {

                        doctype = docname;

                    }

                } else if (doctype == null) {

                    // because docname is not null and it is declared in dtd

                    // so could not be in schema, no namespace

                    doctype = docname;

                }

                rootNode.writeNodename(docname);

                //System.out.println("here!!!!!!!!!!!!!!!!!!1");

                  // described element. If it has a descirbed element,

                  // this code would hurt any thing

                  processAdditionalAccess = true;

                }

                        localName, prefix, MetaCatUtil.normalize(null));

              storedAccessNodeStack.push(nodeElement);

              processAdditionalAccess = true;

            }

            else if (inAddtionalMetaData && processAdditionalAccess &&

                     parentNode.getTagName().equals(ADDITIONALMETADATA) &&

               // If additionalMetadata has access element, the flag will be

               // terminated in endElement

               processAdditionalAccess = false;

            }

            else if (currentNode.getTagName().equals(DISTRIBUTION) &&

                     !inAddtionalMetaData)

            inlineDataNameSpace = null;

            inlineDataNameSpace = new Hashtable();

            //write inline data into file

            writeInlineDataIntoFile(inlineDataFileWriter, inlineElements);

        }//else

        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

    /** SAX Handler that is called for each XML text node */

    public void characters(char[] cbuf, int start, int len) throws SAXException

    {

        if (!handleInlineData) {

            // buffer all text nodes for same element. This is for text was

            // splited

            // so we can save memory

            if (textBuffer.length() >= MAXDATACHARS)

            {

                DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

                endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

                        currentNode);

            // we don't need to buffered it.

            StringBuffer inlineText = new StringBuffer();

            inlineText.append(new String(cbuf, start, len));

                    "The inline text data write into file system: "

            writeInlineDataIntoFile(inlineDataFileWriter, inlineText);

        }

    }

    public void endElement(String uri, String localName, String qName)

            throws SAXException

    {

        // when close inline element

        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

            // Get the node from the stack

            DBSAXNode currentNode = (DBSAXNode) nodeStack.pop();

            String currentTag = currentNode.getTagName();

            // close file writer

            try

            {

                  }

                  else

                  {

                               "inline data was changed by a user"

                    throw new SAXException(PERMISSIONERROR);

                  }

                  // user get the inline data

                  if (modifiedInlineData(distributionId, inlineDataFileName))

                  {

                                "inline data was changed by a user"

                    throw new SAXException(PERMISSIONERROR);

                  }//if

                }//else

                }//else if

                // write text to db if it is not inline data

                 // write text node into db

                 endNodeId = writeTextForDBSAXNode(endNodeId, textBuffer,

            endElement.append("</");

            endElement.append(qName);

            endElement.append(">");

            writeInlineDataIntoFile(inlineDataFileWriter, endElement);

        }

        //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

       {

         return modified;

       }

       try

       {

     */

    public void comment(char[] ch, int start, int length) throws SAXException

    {

        if (!handleInlineData) {

            if (!processingDTD) {

                DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            inlineComment.append("<!--");

            inlineComment.append(new String(ch, start, length));

            inlineComment.append("-->");

            writeInlineDataIntoFile(inlineDataFileWriter, inlineComment);

        }

    }

    public void processingInstruction(String target, String data)

            throws SAXException

    {

        if (!handleInlineData) {

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            endNodeId = currentNode.writeChildNodeToDB("PI", target, data,

            inlinePI.append(" ");

            inlinePI.append(data);

            inlinePI.append("?>");

            writeInlineDataIntoFile(inlineDataFileWriter, inlinePI);

        }

    }

    public void startPrefixMapping(String prefix, String uri)

            throws SAXException

    {

        if (!handleInlineData) {

            namespaces.put(prefix, uri);

        } else {

        // When validation is turned "on", white spaces are reported here

        // When validation is turned "off" white spaces are not reported here,

        // but through characters() callback

        if (!handleInlineData) {

            DBSAXNode currentNode = (DBSAXNode) nodeStack.peek();

            String data = null;

    /** SAX Handler that receives notification of end of the document */

    public void endDocument() throws SAXException

    {

        if (needCheckingAccessModule)

        {

          compareAllAccessModules();

  {

      // make sure stack1 and stack2 are not empty

      if (stack1.isEmpty() || stack2.isEmpty()) {

          throw new SAXException(UPDATEACCESSERROR);

      }

      // go throw two stacks and compare every element

              record2 = (NodeRecord) stack2.pop();

          } catch (EmptyStackException ee) {

              throw new SAXException(UPDATEACCESSERROR);

          }

          // if two records are not same throw a exception

          if (!record1.contentEquals(record2)) {

              throw new SAXException(UPDATEACCESSERROR);

          }//if

      }//while

      // now stack1 is empty and we should make sure stack2 is empty too

      if (!stack2.isEmpty()) {

                  "stack2 still have some elements while stack1 "

          throw new SAXException(UPDATEACCESSERROR);

      }//if

  }//comparingNodeStacks

   {

     if (access == null)

     {

       throw new SAXException("An access modules is null");

     }

     String subTreeId = access.getSubTreeId();

       for (int j = 0; j < describeIdList.size(); j++)

       {

         String subreeid = (String)describeIdList.elementAt(j);

         // we need to figure out the real id if this subreeid is points to

         // a distribution reference.

         subreeid = resolveDistributionReference(subreeid);

         if (subreeid != null && !subreeid.trim().equals(""))

         {

           // if this id is for line data, we need to delete the records first

           // then add new records. The key for deleting is subtee id

           if (inlineDistributionIdList.containsKey(subreeid))

             String inlineFileName = (String)

                                        inlineDistributionIdList.get(subreeid);

             deleteSubtreeAccessRule(subreeid);

             writeGivenAccessRuleIntoDB(permOrder, accessRule,

                                        inlineFileName, subreeid);

           }

             // for online data, the subtree id we set is null.

             // So in xml_access, only the inline data subteeid is not null

             String dataFileName = handleOnlineUrlDataFile(url);

             if (dataFileName != null)

             {

               deletePermissionsInAccessTableForDoc(dataFileName);

               writeGivenAccessRuleIntoDB(permOrder, accessRule,

                                          dataFileName, null);

               // put the id into a hashtalbe. So when we run wirtetop level

               // access, those id will be ignored because they already has

               // additional access rules

          dataId.trim().equals("") || accessRules == null ||

          accessRules.isEmpty())

      {

        throw new SAXException("The access object is null");

      }

       // get rid of rev from dataId

           connection.increaseUsageCount(1);

           // Bind the values to the query

           pstmt.setString(1, dataId);

           pstmt.setString(6, docid);

           pstmt.setString(5, permOrder);

           pstmt.setString(7, subTreeId);

           // if it is not top level, set s id

           //Vector accessRules = accessSection.getAccessRules();

               String permType = rule.getPermissionType();

               int permission = rule.getPermission();

               pstmt.setInt(3, permission);