package org.apache.commons.digester3.examples.api.dbinsert;
   
   /*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */ 
  
  import java.io.File;
  import java.io.IOException;
  import java.sql.Connection;
  
  import org.apache.commons.digester3.Digester;
  import org.xml.sax.SAXException;
  
  /**
   * A simple program to demonstrate that the Commons Digester module can be
   * used to trigger actions as the xml is parsed, rather than just build
   * up in-memory representations of the parsed data. This example also shows
   * how to write a custom Rule class.
   * <p>
   * This code will parse the provided "example.xml" file, and immediately 
   * insert the processed data into a database as each row tag is parsed,
   * instead of building up an in-memory representation. Actually, in order 
   * to keep this example simple and easy to run, sql insert statements are 
   * printed out rather than actually performing database inserts, but the 
   * principle remains.
   * <p> 
   * Very verbose comments are included here, as this class is intended
   * as a tutorial; if you look closely at method "addRules", you will
   * see that the amount of code required to use the Digester is actually
   * quite low.
   * <p>
   * Usage: java Main example.xml
   */
  public class Main
  {
  
      /**
       * Main method : entry point for running this example program.
       * <p>
       * Usage: java Main example.xml
       */
      public static void main( String[] args )
      {
          if ( args.length != 1 )
          {
              usage();
              System.exit( -1 );
          }
  
          String filename = args[0];
  
          // Create a Digester instance
          Digester d = new Digester();
  
          // Here you would establish a real connection.
          // There would also be a finally clause to ensure it is
          // closed after parsing terminates, etc.
          Connection connection = null;
  
          // Add rules to the digester that will be triggered while
          // parsing occurs.
          addRules( d, connection );
  
          // Process the input file.
          System.out.println( "Parsing commencing..." );
          try
          {
              File srcfile = new File( filename );
              d.parse( srcfile );
          }
          catch ( IOException ioe )
          {
              System.out.println( "Error reading input file:" + ioe.getMessage() );
              System.exit( -1 );
          }
          catch ( SAXException se )
          {
              System.out.println( "Error parsing input file:" + se.getMessage() );
              System.exit( -1 );
          }
  
          // And here there is nothing to do. The digester rules have
          // (deliberately) not built a representation of the input, but
          // instead processed the data as it was read.
          System.out.println( "Parsing complete." );
      }
 
     private static void addRules( Digester d, java.sql.Connection conn )
     {
 
         // --------------------------------------------------
         // when we encounter a "table" tag, do the following:
 
         // Create a new instance of class Table, and push that
         // object onto the digester stack of objects. We only need
         // this so that when a row is inserted, it can find out what
         // the enclosing tablename was.
         //
         // Note that the object is popped off the stack at the end of the
         // "table" tag (normal behaviour for ObjectCreateRule). Because we
         // never added the table object to some parent object, when it is
         // popped off the digester stack it becomes garbage-collected. That
         // is fine in this situation; we've done all the necessary work and
         // don't need the table object any more.
         d.addObjectCreate( "database/table", Table.class );
 
         // Map *any* attributes on the table tag to appropriate
         // setter-methods on the top object on the stack (the Table
         // instance created by the preceeding rule). We only expect one
         // attribute, though: a 'name' attribute specifying what table
         // we are inserting rows into.
         d.addSetProperties( "database/table" );
 
         // --------------------------------------------------
         // When we encounter a "row" tag, invoke methods on the provided
         // RowInserterRule instance.
         //
         // This rule creates a Row instance and pushes it on the digester
         // object stack, rather like ObjectCreateRule, so that the column
         // tags have somewhere to store their information. And when the
         // </row> end tag is found, the rule will trigger to remove this
         // object from the stack, and also do an actual database insert.
         //
         // Note that the rule instance we are passing to the digester has
         // been initialised with some useful data (the SQL connection).
         //
         // Note also that in this case we are not using the digester's
         // factory methods to create the rule instance; that's just a
         // convenience - and obviously not an option for Rule classes
         // that are not part of the digester core implementation.
         RowInserterRule rowInserterRule = new RowInserterRule( conn );
         d.addRule( "database/table/row", rowInserterRule );
 
         // --------------------------------------------------
         // when we encounter a "column" tag, call setColumn on the top
         // object on the stack, passing two parameters: the "name"
         // attribute, and the text within the tag body.
         d.addCallMethod( "database/table/row/column", "addColumn", 2 );
         d.addCallParam( "database/table/row/column", 0, "name" );
         d.addCallParam( "database/table/row/column", 1 );
     }
 
     private static void usage()
     {
         System.out.println( "Usage: java Main example.xml" );
     }
 
 }