SimpleJdbcDocumentProducer.java

/*
 * Copyright 2007  T-Rank AS
 * 
 * Licensed 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.
 */
package no.trank.openpipe.jdbc;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.JdbcTemplate;

import static no.trank.openpipe.api.document.DocumentOperation.*;

/**
 * A simple document producer for getting documents from a jdbc source.
 *
 * The producer can trigger add, modify and/or deletes. Each operation has a corresponding pre, post, fail and list
 * sqls. Ex: for add you have the setters: setAddPreSql(...), setAddSql(...), setAddPostSql(...) and
 * setAddFailSql(List<String> sql).
 *
 * For each operation type (add, modify, delete):<br/>
 * - The preSql is run<br/>
 * - Each document is produced by running the producer sql. There is no guarantee that all documents are fetched before
 * next step happens. But it is guaranteed that a after a post/failSql a new preSql is run before new documents are
 * fetched.<br/>
 * - If no errors happened the postSql is run.</br>
 * - If an error happened the failSql is run.</br>
 *
 * To use:
 *
 * 1. Set the JdbcTemplate (and its dataSource)</br>
 * 2. Set the sqls for producing documents.</br>
 *
 * @version $Revision$
 */
public class SimpleJdbcDocumentProducer extends JdbcDocumentProducer {
   private static final Logger log = LoggerFactory.getLogger(SimpleJdbcDocumentProducer.class);
   private final Map<String, SqlOperationPart> opPartsMap = new LinkedHashMap<String, SqlOperationPart>();

   @Override
   public void init() {
      super.setOperationParts(new ArrayList<OperationPart>(opPartsMap.values()));
      super.init();
   }

   private static <T> List<T> notNull(List<T> list) {
      return list == null ? Collections.<T>emptyList() : list;
   }

   private static void execute(JdbcTemplate jdbcTemplate, List<String> sqls) throws DataAccessException {
      for (String sql : sqls) {
         log.debug("Executing sql {}", sql);
         jdbcTemplate.execute(sql);
      }
   }

   private SqlOperationPart getPart(String operation) {
      SqlOperationPart part = opPartsMap.get(operation);
      if (part == null) {
         part = new SqlOperationPart(operation);
         opPartsMap.put(operation, part);
      }
      return part;
   }

   /**
    * Set a list of preSqls to run.
    *
    * @param operation the operation that this preSql is used for.
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setPreSql(String operation, List<String> sql) {
      getPart(operation).setPreSql(sql);
   }

   /**
    * Set a list of sqls to run to get the documents.
    *
    * @param operation the operation that this preSql is used for.
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setSql(String operation, List<String> sql) {
      getPart(operation).setSqls(sql);
   }

   /**
    * Set a list of sqls to run after documents have been fetched.
    *
    * @param operation the operation that this preSql is used for.
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setPostSql(String operation, List<String> sql) {
      getPart(operation).setPostSql(sql);
   }

   /**
    * Set a list of sqls to run if there was an error in the pipeline.
    *
    * @param operation the operation that this preSql is used for.
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   private void setFailSql(String operation, List<String> sql) {
      getPart(operation).setFailSql(sql);      
   }

   /**
    * Set a list of preSqls to run before producing add Documents.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setAddPreSql(List<String> sql) {
      setPreSql(ADD_VALUE, sql);
   }

   /**
    * Set a list of sqls to run for producing add Documents.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setAddSql(List<String> sql) {
      setSql(ADD_VALUE, sql);
   }

   /**
    * Set a list of sqls to run after add documents have been produced. (If no error happened)
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setAddPostSql(List<String> sql) {
      setPostSql(ADD_VALUE, sql);
   }

   /**
    * Set a list of sqls to run after add documents have been produced and some error happened.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setAddFailSql(List<String> sql) {
      setFailSql(ADD_VALUE, sql);
   }

   /**
    * Set a list of preSqls to run before producing modify Documents.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setModifyPreSql(List<String> sql) {
      setPreSql(MODIFY_VALUE, sql);
   }

   /**
    * Set a list of sqls to run for producing modify Documents.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setModifySql(List<String> sql) {
      setSql(MODIFY_VALUE, sql);
   }

   /**
    * Set a list of sqls to run after modify documents have been produced. (If no error happened)
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setModifyPostSql(List<String> sql) {
      setPostSql(MODIFY_VALUE, sql);
   }

   /**
    * Set a list of sqls to run after modify documents have been produced and some error happened.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setModifyFailSql(List<String> sql) {
      setFailSql(MODIFY_VALUE, sql);
   }

   /**
    * Set a list of preSqls to run before producing delete Documents.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setDeletePreSql(List<String> sql) {
      setPreSql(DELETE_VALUE, sql);
   }

   /**
    * Set a list of sqls to run for producing delete Documents.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setDeleteSql(List<String> sql) {
      setSql(DELETE_VALUE, sql);
   }

   /**
    * Set a list of sqls to run after delete documents have been produced. (If no error happened)
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */
   public void setDeletePostSql(List<String> sql) {
      setPostSql(DELETE_VALUE, sql);
   }

   /**
    * Set a list of sqls to run after delete documents have been produced and some error happened.
    *
    * @param sql a list of sql to run as preSql
    * @see no.trank.openpipe.api.document.DocumentOperation
    */      
   public void setDeleteFailSql(List<String> sql) {
      setFailSql(DELETE_VALUE, sql);
   }


   private static class SqlOperationPart implements OperationPart {
      private final String operation;
      private List<String> preSql = Collections.emptyList();
      private List<String> sqls = Collections.emptyList();
      private List<String> postSql = Collections.emptyList();
      private List<String> failSql = Collections.emptyList();

      public SqlOperationPart(String operation) {
         this.operation = operation;
      }

      @Override
      public boolean isEmpty() {
         return preSql.isEmpty() && sqls.isEmpty() && postSql.isEmpty();
      }

      @Override
      public String getOperation() {
         return operation;
      }

      @Override
      public void doPreSql(JdbcTemplate jdbcTemplate) throws DataAccessException {
         execute(jdbcTemplate, preSql);
      }

      @Override
      public void doPostSql(JdbcTemplate jdbcTemplate) throws DataAccessException {
         execute(jdbcTemplate, postSql);
      }

      @Override
      public void doFailSql(JdbcTemplate jdbcTemplate) throws DataAccessException {
         execute(jdbcTemplate, failSql);
      }

      @Override
      public List<String> getSqls() {
         return sqls;
      }

      public void setSqls(List<String> sqls) {
         this.sqls = notNull(sqls);
      }

      public void setPreSql(List<String> preSql) {
         this.preSql = notNull(preSql);
      }

      public void setPostSql(List<String> postSql) {
         this.postSql = notNull(postSql);
      }

      public void setFailSql(List<String> failSql) {
         this.failSql = notNull(failSql);
      }
   }
}