/*

  * 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.commons.performance.dbcp;

 import java.sql.Connection;

 import java.sql.ResultSet;

 import java.sql.Statement;

 import java.util.logging.Logger;

 import javax.sql.DataSource;

 import org.apache.commons.performance.ClientThread;

 import org.apache.commons.performance.Statistics;

 /**

  * Client thread that executes requests in a loop using a configured

  * DataSource, with the number of requests, time between requests and 

  * query strings governed by constructor parameters. See 

  * {@link ClientThread ClientThread javadoc} for a description

  * of how times between requests are computed.

  *

  */

 public class DBCPClientThread extends ClientThread {

     /** Initial segment of query string */

     private String queryString = null;

     /** Whether or not the query is on the text column */

     private boolean textQuery = false;

     /** DataSource used to connect */

     private DataSource dataSource = null;

     /** Database connection */

     Connection conn = null;

     /** Current query */

     String currentQuery = null;

     /**

      * Create a dbcp client thread.

      * 

      * @param iterations number of iterations

      * @param minDelay minimum delay time between client requests

      * @param maxDelay maximum delay time between client requests

      * @param sigma standard deviation of delay times between client requests

      * @param delayType distribution of time between client requests

      * @param queryType type of query 

      * @param rampPeriod rampup, rampdown period for cyclic load

      * @param peakPeriod period of sustained peak for cyclic load

      * @param troughPeriod period of sustained minimum load

      * @param cycleType type of cycle for mean delay

      * @param rampType type of ramp (linear or random jumps)

      * @param logger common logger shared by all clients

      * @param dataSource DataSource for connections

      * @param stats Statistics container

      */

     public DBCPClientThread(long iterations, long minDelay, long maxDelay,

             double sigma, String delayType, String queryType, long rampPeriod,

             long peakPeriod, long troughPeriod, String cycleType,

             String rampType, Logger logger, DataSource dataSource,

             Statistics stats) {

         super(iterations, minDelay, maxDelay, sigma, delayType, rampPeriod,

                 peakPeriod, troughPeriod, cycleType, rampType, logger,

                 stats);

         this.dataSource = dataSource;

         if (queryType.equals("no-op")) {

             return;

         }

         if (queryType.equals("integerIndexed")) {

             queryString = "select * from test_table WHERE indexed=";

         } else if (queryType.equals("integerScan")) {

             queryString = "select * from test_table WHERE not_indexed=";  

         } else {

             queryString = "select * from test_table WHERE text='"; 

             textQuery = true;

         }

     }

     /** Generate a random query */

     public void setUp() throws Exception {

         if (queryString == null) {

             return;

         }

         if (textQuery) {

             currentQuery = queryString +

                 randomData.nextHexString(20) + "';";

         } else {

             currentQuery = queryString +

                 randomData.nextInt(0, 100) + ";";

         }

     }

     /** Execute query */

     public void execute() throws Exception {

         conn = dataSource.getConnection();

         if (queryString == null) {

             return;

         }

         Statement stmt = conn.createStatement();

         stmt.execute(currentQuery);

         ResultSet rs = stmt.getResultSet();

         if (!rs.isAfterLast()) {

             rs.next();

         }

         rs.close();

         stmt.close();

     }

     /** Close connection */

     public void cleanUp() throws Exception {

         if (conn != null) {

             try {

                 conn.close();

             } finally {

                 conn = null;

             } 

         }

     }

 }