path: root/sandbox/lresende/backup/container.das/src/main/java/org/apache/tuscany/container/dataaccessscript/DataAccessInstanceImpl.java

/*
 * 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.    
 */
package org.apache.tuscany.container.dataaccessscript;

import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Vector;

import org.apache.tuscany.container.dataaccess.DataAccessInstance;
import org.apache.tuscany.das.rdb.Command;
import org.apache.tuscany.das.rdb.DAS;

import commonj.sdo.DataObject;
/**
 * An invokeable instance of a DataAccess config script.
 */
public class DataAccessInstanceImpl implements DataAccessInstance {
    
    private DAS dasInstance;
    private String dataAccessType;
    private String tableName = null;
    private String genericSelectForRoot = "select * from "+ tableName;
    
    public DataAccessInstanceImpl(DAS das, String dataAccessType){
        this.dasInstance = das;
        this.dataAccessType = dataAccessType;
    }
    
    public Object invokeFunction(String functionName, Object[] args, Class returnType) {
        Command cmd = null;
        //System.out.println("functionName:"+functionName);
        
        Vector paramsList = null;
        if(args != null){
            try{
                paramsList = (Vector)args[0];
            }catch(ClassCastException e){
                //TODO
                e.printStackTrace();
            }
        }
        
        //if any of the  3 below - its dynamic way , else , its static way
        if(! "execute".equals(functionName) && 
                ! "executeQuery".equals(functionName) &&
                    ! "applyChanges".equals(functionName)){
            //try for static way
            try{
                String commandName = CommandMapper.getCommandName(functionName);
                //System.out.println("commandName:"+commandName);
                if(paramsList != null && paramsList.size()>1 && 
                        paramsList.get(1).toString().indexOf(DataAccessEngine.SEPARATOR) == -1){
                    cmd = dasInstance.getCommand(commandName);//got in static way   
                }               
            }catch(Exception e){
                //TODO
                e.printStackTrace();//if command not found in config or other exception
            }
        }
        else{//dynamic way
            //upto below statement is generic DAS..but select,etc..are particular
            //to RDBDAS
            //TODO if no matching command is found
            if(!((String)paramsList.get(0)).equals("")){
             cmd = dasInstance.getCommand((String)paramsList.get(0));//got in dynamic way
            }else{
                //this can be insert or delete as applyChanges-dynamic way
            }
        }
        
        //TODO handle better
        //this is not error case - as can be case for dynamic/static approach with applyChanges(), where command is
        //obtained for generic select at later point. So, don't throw exception
        /*if(cmd == null){
            Exception e = new Exception("No command could be found!");
            e.printStackTrace();
        }*/
                
        //Particular to RDBDAS
        if(this.dataAccessType.equals(DataAccessEngine.RDB)){
            DataObject dataObj = null;
            dataObj = invokeRDBDASFunction(cmd, paramsList);
            return dataObj;
        }
        
        //TODO ...implement for other than RDB
        return null;
    }
    
    private DataObject invokeRDBDASSelect(Command cmd, Vector paramsList){
        DataObject dObject = null;

        if(paramsList != null && paramsList.size()>=3){
            Map<Integer, Object> inParams = new Hashtable<Integer, Object>();
            inParams = (Map<Integer, Object>)paramsList.get(2);
            DataAccessUtils.fromJavaToRDBDASPositionBased(inParams, cmd);
        }
        dObject = cmd.executeQuery();   
        if(dObject == null){
            System.out.println("null result returned in select");
        }
        //dasInstance.releaseResources();
        return dObject;
    }
    
    private void invokeRDBDASDeleteExecute(Command cmd, Vector paramsList){
        if(paramsList != null && paramsList.size()>=3){
            Map<Integer, Object> inParams = new Hashtable<Integer, Object>();
            inParams = (Map<Integer, Object>)paramsList.get(2);
            DataAccessUtils.fromJavaToRDBDASPositionBased(inParams, cmd);
        }
        cmd.execute();
        //dasInstance.releaseResources();
    }    
    
    private void invokeRDBDASDeleteApplyChanges(Command cmd, Vector paramsList){
        if(paramsList != null && paramsList.size()>=3){
            String paramsTableName = paramsList.get(1).toString();
            int idx = paramsTableName.indexOf(DataAccessEngine.SEPARATOR);
            tableName = paramsTableName.substring(idx+1);
            genericSelectForRoot = "select * from "+ tableName;
            //System.out.println("genericSelectForRoot:"+genericSelectForRoot);
            cmd = dasInstance.createCommand(genericSelectForRoot);
            
            //set WHERE params
            if(paramsList.get(2) instanceof Map){
                Map<String, Object> whereParams = (Map<String, Object>)paramsList.get(2);
                
                String whereStr = null;
                //TODO needs better way
                if(whereParams != null && whereParams.size()>  0){
                    for (Iterator i = whereParams.keySet().iterator(); i.hasNext();) {
                        String idxDel = (String)i.next();

                        Object val = whereParams.get(idxDel);
                        whereStr = tableName+"["+val+"]";
                        //System.out.println("whereStr:"+whereStr);
                    }
                    DataObject root = cmd.executeQuery();
                    DataObject dObj = root.getDataObject(whereStr);
                    dObj.delete();
                    dasInstance.applyChanges(root);
                }
            }       
        }
        
        //dasInstance.releaseResources();
    }
    
    private void invokeRDBDASInsertExecute(Command cmd, Vector paramsList){
        if(paramsList != null && paramsList.size()>=3){
            Map<Integer, Object> inParams = new Hashtable<Integer, Object>();
            inParams = (Map<Integer, Object>)paramsList.get(2);
            DataAccessUtils.fromJavaToRDBDASPositionBased(inParams, cmd);
        }
        //System.out.println("before execute insert");
        
        cmd.execute();  
        //dasInstance.releaseResources();
    }
    
    private void invokeRDBDASInsertApplyChanges(Command cmd, Vector paramsList){
        if(paramsList != null && paramsList.size()>=3){
            String paramsTableName = paramsList.get(1).toString();
            int idx = paramsTableName.indexOf(DataAccessEngine.SEPARATOR);
            tableName = paramsTableName.substring(idx+1);
            genericSelectForRoot = "select * from "+ tableName;
            //System.out.println("genericSelectForRoot:"+genericSelectForRoot);
            cmd = dasInstance.createCommand(genericSelectForRoot);
            
            //set INSERT params
            if(paramsList.get(2) instanceof Map){
                Map<String, Object> insertParams = (Map<String, Object>)paramsList.get(2);
                DataObject root = cmd.executeQuery();
                DataObject insertObj = root.createDataObject(tableName);
                
                if(insertParams != null && insertParams.size()>  0){
                    for (Iterator i = insertParams.keySet().iterator(); i.hasNext();) {
                        String idxIns = (String)i.next();
            
                        Object val = insertParams.get(idxIns);
                        //System.out.println(idxIns+","+val+val.getClass().getName());
                        insertObj.set(idxIns, val);
                    }
                    
                }                               
                
                dasInstance.applyChanges(root);
            }
        } 
        //dasInstance.releaseResources();
    }
    
    private void invokeRDBDASUpdate(Command cmd, Vector paramsList){
        if(paramsList != null && paramsList.size()>=4){
            String paramsTableName = paramsList.get(1).toString();
            int idx = paramsTableName.indexOf(DataAccessEngine.SEPARATOR);
            tableName = paramsTableName.substring(idx+1);
            genericSelectForRoot = "select * from "+ tableName;
            //System.out.println("genericSelectForRoot:"+genericSelectForRoot);
            cmd = dasInstance.createCommand(genericSelectForRoot);
            
            //set UPD and WHERE params
            if(paramsList.get(2) instanceof Map){
                Map<String, Object> updParams = (Map<String, Object>)paramsList.get(2);
                
                if(paramsList.get(3) instanceof Map){
                    Map<String, Object> whereParams = (Map<String, Object>)paramsList.get(3);
                    DataObject root = DataAccessUtils.fromJavaToRDBDASNameBased(updParams, whereParams, cmd, tableName);
                    dasInstance.applyChanges(root);
                }
            }
        }
        //dasInstance.releaseResources();
    }

    private DataObject invokeRDBDASProcedure(Command cmd, Vector paramsList){
        DataObject dataObj = null; 
        if(paramsList != null && paramsList.size()>=3){
            //set IN params
            if(paramsList.get(2) instanceof Map){
                Map<Integer, Object> inParams = (Map<Integer, Object>)paramsList.get(2);
                DataAccessUtils.fromJavaToRDBDASPositionBased(inParams, cmd);               
            }
            
            dataObj = cmd.executeQuery();
            
            if(paramsList.size()>=4 && paramsList.get(3) instanceof Map){
                try{
                    Map<Integer, Object> outParams = (Map<Integer, Object>)paramsList.get(3);
                    DataAccessUtils.fromRDBDASToJavaPositionBased(outParams, cmd);
                    paramsList.add(3, outParams);
                }catch(Exception e){
                    //TODO what if map is not of proper type
                    e.printStackTrace();
                }
            }
            
            //System.out.println("executed SP..");          
        }
        //dasInstance.releaseResources();
        return dataObj;  // NOPMD
    }

    //this method detects further what exact DAS function needs to be called e.g. applyChanges(), ...
    private DataObject invokeRDBDASFunction(Command cmd, Vector paramsList){
        String commandKind = null; 
        commandKind = (String)paramsList.get(1);//e.g. select, update, - sim. to one in DAS config for current command


        
        //System.out.println("commandKind:"+commandKind);
        //static or dynamic both - executeQuery()
        if(commandKind.equals(DataAccessEngine.SELECT)){
            DataObject dataObj = invokeRDBDASSelect(cmd, paramsList);           
            return dataObj; //NOPMD
        }
        
        //Delete can happen through execute() or applyChanges() 
        if(commandKind.startsWith(DataAccessEngine.DELETE)){
            if(paramsList.get(0).toString().equals("")){
                if(commandKind.indexOf(DataAccessEngine.SEPARATOR) != -1){//this will be applyChanges()-static/dynamic delete:tableName - cmd has no meaning here 
                    invokeRDBDASDeleteApplyChanges(cmd, paramsList);
                }else{//this will be execute() - static
                    invokeRDBDASDeleteExecute(cmd, paramsList);
                    return null;
                }
            }else{//this will be execute() - dynamic
                invokeRDBDASDeleteExecute(cmd, paramsList);
                return null;
            }
            
            return null;
        }
        
        //Insert can happen through execute() or applyChanges()
        if(commandKind.startsWith(DataAccessEngine.INSERT)){
            if(paramsList.get(0).toString().equals("")){
                if(commandKind.indexOf(DataAccessEngine.SEPARATOR) != -1){//this will be applyChanges()-static/dynamic
                    invokeRDBDASInsertApplyChanges(cmd, paramsList);
                }
                else{//this will be execute() - static
                    //System.out.println("calling insert execute");
                    invokeRDBDASInsertExecute(cmd, paramsList);
                    return null;
                }               
            }
            else{//this will be execute() - dynamic
                    //System.out.println("calling insert execute");
                    invokeRDBDASInsertExecute(cmd, paramsList);
                    return null;
            }           
            
            return null;
        }
        
        if(commandKind.startsWith(DataAccessEngine.UPDATE)){//update:tableName
            invokeRDBDASUpdate(cmd, paramsList); //cmd has no meaning here 
            return null;
        }
        
        if(commandKind.equals(DataAccessEngine.PROCEDURE)){//executeQuery()
            DataObject dataObj = invokeRDBDASProcedure(cmd, paramsList);
            return dataObj; 
        }
        

        return null;
    }
}