trait Client extends Closable
A MySQL client that is not Service
-based like com.twitter.finagle.Mysql.Client is,
making it easier to use for most cases.
Creation:
import com.twitter.finagle.Mysql import com.twitter.finagle.mysql.Client val client: Client = Mysql.client .withCredentials("username", "password") .withDatabase("database") .newRichClient("host:port")
- Alphabetic
- By Inheritance
- Client
- Closable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def close(deadline: Time): Future[Unit]
- Definition Classes
- Closable
- abstract def cursor(sql: String): CursoredStatement
Create a CursoredStatement with the given parameterized sql query.
Create a CursoredStatement with the given parameterized sql query. The returned cursored statement can be reused and applied with varying parameters.
- Note
The cursored statements are built on a prepare -> execute -> fetch flow that requires state tracking. It is important to either fully consume the resulting stream, or explicitly call CursorResult.close().
- abstract def ping(): Future[Unit]
Returns the result of pinging the server.
- abstract def prepare(sql: String): PreparedStatement
Returns a new PreparedStatement instance based on the given sql query.
Returns a new PreparedStatement instance based on the given sql query. The returned prepared statement can be reused and applied with varying parameters.
- Note
Mysql prepared statements are stateful, that is, they allocate resources on the mysql server. The allocations are managed by a finagle-mysql connection. Closing the client implicitly closes all outstanding PreparedStatements.
- abstract def query(sql: String): Future[Result]
Returns the result of executing the
sql
query on the server. - abstract def select[T](sql: String)(f: (Row) => T): Future[Seq[T]]
Sends the given
sql
to the server and maps each resulting row tof
, a function from Row => T.Sends the given
sql
to the server and maps each resulting row tof
, a function from Row => T. If no ResultSet is returned, the function returns an empty Seq.import com.twitter.finagle.mysql.Client import com.twitter.util.Future val client: Client = ??? val names: Future[Seq[String]] = client.select("SELECT name FROM employee") { row => row.stringOrNull("name") }
- See also
Example: - abstract def session[T](f: (Client with Transactions with Session) => Future[T]): Future[T]
Reserve a session for exclusive use.
Reserve a session for exclusive use. This can be useful when operations that require connection state are to be performed, for example: transactions, locks, or cursors.
A session's life cycle is managed through the completion of the provided Future. If a session is no longer usable it can be explicitly discarded.
import com.twitter.finagle.mysql.{Client, Transactions} import com.twitter.util.{Future, Throw} case class ReallyBadException() extends Exception val client: Client with Transactions = ??? client.session { session => val result = for { _ <- session.query("LOCK") r <- session.transaction { tx => tx.query("...") } _ <- session.query("UNLOCK") } yield r result.rescue { case e: ReallyBadException => session.discard().flatMap(_ => Future.exception(e) ) } }
- See also
Session
Example:
Concrete Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- def close(after: Duration): Future[Unit]
- Definition Classes
- Closable
- final def close(): Future[Unit]
- Definition Classes
- Closable
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable])
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def modify(sql: String): Future[OK]
Executes the given DML (e.g.
Executes the given DML (e.g. INSERT/UPDATE/DELETE) or DDL (e.g. CREATE TABLE, DROP TABLE, COMMIT, START TRANSACTION, etc) given by
sql
.import com.twitter.finagle.mysql.{Client, OK} import com.twitter.util.Future val client: Client = ??? val result: Future[OK] = client.modify("INSERT INTO employee (name) VALUES ('Alice')")
- See also
Example: - final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- def read(sql: String): Future[ResultSet]
Executes the given SELECT query given by
sql
.Executes the given SELECT query given by
sql
.import com.twitter.finagle.mysql.{Client, ResultSet} import com.twitter.util.Future val client: Client = ??? val resultSet: Future[ResultSet] = client.read("SELECT name FROM employee")
- See also
Example: - 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(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()