Connection

Base interface for all objects that behave like a connection. This trait will usually be implemented by the objects that connect to a database, either over the filesystem or sockets. Connection are not supposed to be thread-safe and clients should assume implementations **are not** thread safe and shouldn't try to perform more than one statement (either common or prepared) at the same time. They should wait for the previous statement to be executed to then be able to pick the next one.

You can, for instance, compose on top of the futures returned by this class to execute many statements at the same time:

val handler: Connection = ...
val result: Future[QueryResult] = handler.connect
  .map(parameters => handler)
  .flatMap(connection => connection.sendQuery("BEGIN TRANSACTION ISOLATION LEVEL REPEATABLE READ"))
  .flatMap(query => handler.sendQuery("SELECT 0"))
  .flatMap(query => handler.sendQuery("COMMIT").map(value => query))

val queryResult: QueryResult = Await.result(result, Duration(5, SECONDS))

Linear Supertypes

AnyRef, Any

Known Subclasses

ConnectionPool, PartitionedConnectionPool

Abstract Value Members

abstract def connect: Future[Connection]

Connects this object to the database.
Connects this object to the database. Connection objects are not necessarily created with a connection to the database so you might have to call this method to be able to run queries against it.
returns
abstract def disconnect: Future[Connection]

Disconnects this object.
Disconnects this object. You should discard this object after calling this method. No more queries will be accepted.
returns
abstract def isConnected: Boolean

Checks whether we are still connected to the database.
Checks whether we are still connected to the database.
returns
abstract def sendPreparedStatement(query: String, values: Seq[Any] = List()): Future[QueryResult]

Sends a prepared statement to the database.
Sends a prepared statement to the database. Prepared statements are special statements that are pre-compiled by the database to run faster, they also allow you to avoid SQL injection attacks by not having to concatenate strings from possibly unsafe sources (like users) and sending them directy to the database.
When sending a prepared statement, you can insert ? signs in your statement and then provide values at the method call 'values' parameter, as in:
```
connection.sendPreparedStatement( "SELECT * FROM users WHERE users.login = ?", Array( "john-doe" ) )
```
As you are using the ? as the placeholder for the value, you don't have to perform any kind of manipulation to the value, just provide it as is and the database will clean it up. You must provide as many parameters as you have provided placeholders, so, if your query is as "INSERT INTO users (login,email) VALUES (?,?)" you have to provide an array with at least two values, as in:
```
Array("john-doe", "[email protected]")
```
You can still use this method if your statement doesn't take any parameters, the default is an empty collection.
query
values
returns
abstract def sendQuery(query: String): Future[QueryResult]

Sends a statement to the database.
Sends a statement to the database. The statement can be anything your database can execute. Not all statements will return a collection of rows, so check the returned object if there are rows available.
query
returns

Concrete Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def inTransaction[A](f: (Connection) ⇒ Future[A])(implicit executionContext: ExecutionContext): Future[A]

Executes an (asynchronous) function within a transaction block.
Executes an (asynchronous) function within a transaction block. If the function completes successfully, the transaction is committed, otherwise it is aborted.
f
operation to execute on this connection
returns
result of f, conditional on transaction operations succeeding
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

trait Connection extends AnyRef

Abstract Value Members

abstract def connect: Future[Connection]

abstract def disconnect: Future[Connection]

abstract def isConnected: Boolean

abstract def sendPreparedStatement(query: String, values: Seq[Any] = List()): Future[QueryResult]

abstract def sendQuery(query: String): Future[QueryResult]

Concrete Value Members

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 hashCode(): Int

def inTransaction[A](f: (Connection) ⇒ Future[A])(implicit executionContext: ExecutionContext): Future[A]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

Inherited from AnyRef

Inherited from Any

Ungrouped