ScalaCompositeHandler

abstract def withQueryDetection(arg0: <repeated...>[Pattern]): ScalaCompositeHandler

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def getGeneratedKeys(): ResultSet

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isQuery(arg0: String): Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def queryDetectionPattern(arg0: <repeated...>[Pattern]): Array[Pattern]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def whenSQLQuery(arg0: String, arg1: List[Parameter]): QueryResult

def whenSQLUpdate(arg0: String, arg1: List[Parameter]): UpdateResult

def withQueryDetection(pattern: Pattern*): ScalaCompositeHandler

Returns handler that detects statement matching given pattern(s) as query.

import acolyte.Acolyte.handleStatement

// Created handle will detect as query statements
// either starting with 'SELECT ' or containing 'EXEC proc'.
handleStatement.withQueryDetection("^SELECT ", "EXEC proc")

def withQueryDetection(arg0: <repeated...>[String]): ScalaCompositeHandler

def withQueryHandler(h: (QueryExecution) ⇒ QueryResult): ScalaCompositeHandler

Returns handler that delegates query execution to |h| function.

import acolyte.QueryExecution
import acolyte.Acolyte.handleStatement

handleStatement withQueryHandler { e: QueryExecution => aQueryResult }

// With pattern matching ...
import acolyte.ParameterVal

handleStatement withQueryHandler {
  _ match {
    case QueryExecution("SELECT * FROM Test WHERE id = ?", ParameterVal(1) :: Nil) => aQueryResult
    case _ => otherResult
  }
}

def withUpdateHandler(h: (UpdateExecution) ⇒ UpdateResult): ScalaCompositeHandler

Returns handler that delegates update execution to |h| function.

import acolyte.UpdateExecution
import acolyte.Acolyte.handleStatement

handleStatement withUpdateHandler { e: UpdateExecution => aQueryResult }

// With pattern matching ...
import acolyte.ParameterVal

handleStatement withUpdateHandler {
  _ match {
    case UpdateExecution("INSERT INTO Country (code, name) VALUES (?, ?)", ParameterVal(code) :: ParameterVal(name) :: Nil) => 1 /* update count */   *     case _ => otherResult
  }
}