Type Members

1.  class BigIntTooLongException extends Exception
2.  case class BigIntValue(bi: BigInt) extends Value with Product with Serializable
3.  case class ByteValue(b: Byte) extends Value with Product with Serializable
4.  trait CanBeParameter[-A] extends AnyRef
5.  case class Capability(mask: Int) extends Product with Serializable
6.  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.

   A MySQL client that is not Service-based like com.twitter.finagle.Mysql.Client is, making it easier to use for most cases.

   Example:

   1. 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")

7.  case class CloseRequest(stmtId: Int) extends CommandRequest with Product with Serializable

   A CloseRequest deallocates a prepared statement on the server.

   A CloseRequest deallocates a prepared statement on the server. No response is sent back to the client. https://dev.mysql.com/doc/internals/en/com-stmt-close.html

8.  class ColumnNotFoundException extends SQLNonTransientException with FailureFlags[ColumnNotFoundException]

   Indicates the requested column name was not found.

9.  abstract class CommandRequest extends Request

   A command request is a request initiated by the client and has a cmd byte associated with it.

10.  trait CursorResult[T] extends Closable

    A closable async stream of projected rows from a CursoredStatement.

11.  trait CursoredStatement extends AnyRef

    A CursoredStatement represents a parameterized SQL statement applied concurrently with varying parameters and yields a lazy stream of rows.

    A CursoredStatement represents a parameterized SQL statement applied concurrently with varying parameters and yields a lazy stream of rows.

    These are SQL statements with ?'s used for the parameters which are "filled in" per usage by apply.

    See also

    Client.cursor(String

    PreparedStatement for eager processing of Rows.

12.  trait Decoder[T <: Result] extends (Packet) ⇒ Try[T]

    A decoder for Results contained in a single packet.

13.  case class DoubleValue(d: Double) extends Value with Product with Serializable
14.  case class EOF(warnings: Short, serverStatus: ServerStatus) extends Result with Product with Serializable
15.  case class Error(code: Short, sqlState: String, message: String) extends Result with Product with Serializable
16.  class ExecuteRequest extends CommandRequest

    Uses the binary protocol to build an execute request for a prepared statement.

    Uses the binary protocol to build an execute request for a prepared statement. https://dev.mysql.com/doc/internals/en/com-stmt-execute.html

17.  class FetchRequest extends CommandRequest
18.  case class FetchResult(rowPackets: Seq[Packet], containsLastRow: Boolean) extends Result with Product with Serializable
19.  case class Field(catalog: String, db: String, table: String, origTable: String, name: String, origName: String, charset: Short, displayLength: Int, fieldType: Short, flags: Short, decimals: Byte) extends Result with Product with Serializable
20.  case class FloatValue(f: Float) extends Value with Product with Serializable
21.  case class HandshakeInit(protocol: Byte, version: String, threadId: Int, salt: Array[Byte], serverCapabilities: Capability, charset: Short, status: Short) extends Result with Product with Serializable
22.  class IncompatibleServerError extends Exception

    A base class for exceptions related to client incompatibility with an upstream MySQL server.

23.  case class IntValue(i: Int) extends Value with Product with Serializable
24.  sealed trait IsolationLevel extends AnyRef
25.  case class LongValue(l: Long) extends Value with Product with Serializable
26.  final case class LostSyncException(underlying: Throwable) extends RuntimeException with Product with Serializable

    A LostSyncException indicates that this finagle-mysql client and the MySQL server are no longer able to properly communicate, as there has been a failure to decode a message from the server or data has become corrupted in transmission.

    A LostSyncException indicates that this finagle-mysql client and the MySQL server are no longer able to properly communicate, as there has been a failure to decode a message from the server or data has become corrupted in transmission. It is a fatal error and the communication with the server must be closed, then reopened, and renegotiated.

27.  case class OK(affectedRows: Long, insertId: Long, serverStatus: Int, warningCount: Int, message: String) extends Result with Product with Serializable

    Represents the OK Packet received from the server.

    Represents the OK Packet received from the server. It is sent to indicate that a command (e.g. PreparedStatement.modify) has completed successfully.

    affectedRows

    how many records were changed by the command.

    insertId

    the first automatically generated value successfully inserted for an AUTO_INCREMENT column for an INSERT statement.

    serverStatus

    server status bit mask.

    warningCount

    how many warnings were generated.

    message

    the status message, which will be an empty String if none is present.

28.  sealed trait Parameter extends AnyRef

    A value of type A can implicitly convert to a Parameter if an evidence CanBeParameter[A] is available in scope via the Parameter.wrap or Parameter.wrapOption implicits.

    A value of type A can implicitly convert to a Parameter if an evidence CanBeParameter[A] is available in scope via the Parameter.wrap or Parameter.wrapOption implicits. Explicit conversions are available via Parameter.of and Parameters.of.

    A Scala example with implicits:

    import com.twitter.finagle.mysql.Parameter
    import com.twitter.finagle.mysql.Parameter._
    
    val p: Parameter = "this will get implicitly converted to a Parameter"

    A Scala example without implicits:

    import com.twitter.finagle.mysql.Parameter
    
    val p: Parameter = Parameter.of("explicitly converted to a Parameter")

    A Java example:

    import com.twitter.finagle.mysql.Parameter;
    import com.twitter.finagle.mysql.Parameters;
    
    Parameter p = Parameters.of("explicitly converted to a Parameter");

29.  case class PrepareOK(id: Int, numOfCols: Int, numOfParams: Int, warningCount: Int, columns: Seq[Field] = Nil, params: Seq[Field] = Nil) extends Result with Product with Serializable
30.  case class PrepareRequest(sqlStatement: String) extends SimpleCommandRequest with WithSql with Product with Serializable

    Allocates a prepared statement on the server from the passed in query string.

    Allocates a prepared statement on the server from the passed in query string. https://dev.mysql.com/doc/internals/en/com-stmt-prepare.html

31.  trait PreparedStatement extends AnyRef

    A PreparedStatement represents a parameterized SQL statement which may be applied concurrently with varying parameters.

    A PreparedStatement represents a parameterized SQL statement which may be applied concurrently with varying parameters.

    These are SQL statements with ?'s used for the parameters which are "filled in" per usage by read, select, and modify.

    See also

    Client.prepare(String)

    CursoredStatement for a lazy stream of Rows.

32.  case class QueryRequest(sqlStatement: String) extends SimpleCommandRequest with WithSql with Product with Serializable

    A QueryRequest is used to send the server a text-based query that is executed immediately.

    A QueryRequest is used to send the server a text-based query that is executed immediately. https://dev.mysql.com/doc/internals/en/com-query.html

33.  case class RawValue(typ: Short, charset: Short, isBinary: Boolean, bytes: Array[Byte]) extends Value with Product with Serializable

    A RawValue contains the raw bytes that represent a value and enough meta data to decode the bytes.

    A RawValue contains the raw bytes that represent a value and enough meta data to decode the bytes.

    typ

    The MySQL type code for this value.

    charset

    The charset encoding of the bytes.

    isBinary

    Disambiguates between the text and binary protocol.

    bytes

    The raw bytes for this value.

34.  sealed trait Request extends ProtocolMessage

    A Request is an outgoing message sent by the client as part of the MySQL protocol.

    A Request is an outgoing message sent by the client as part of the MySQL protocol. It is packet-based and based around a MySQL command.

35.  sealed trait Result extends AnyRef
36.  case class ResultSet(fields: Seq[Field], rows: Seq[Row]) extends Result with Product with Serializable
37.  final class RollbackFactory extends ServiceFactoryProxy[Request, Result]

    A ServiceFactory that ensures a ROLLBACK statement is issued when a service is put back into the connection pool.

    A ServiceFactory that ensures a ROLLBACK statement is issued when a service is put back into the connection pool.

    See also

    https://dev.mysql.com/doc/en/implicit-commit.html

38.  trait Row extends AnyRef

    A Row allows you to extract Value's from a MySQL row.

    A Row allows you to extract Value's from a MySQL row.

    Column values can be accessed by the MySQL column name via the typed xyzOrNull and getXyz methods. For example, stringOrNull and getString. The get-prefixed methods return Options and use None to represent a SQL NULL. For SQL NULLs, the or-suffixed methods return null for Object-types and use a sentinel, like 0, for primitives.

    Alternatively, Value's based on the column name can be accessed via the apply method.

    For example, given the query, SELECT 'text' AS str_col, 123 AS int_col, you could extract the columns as such.

    First, in Scala:

    import com.twitter.finagle.mysql.Row
    val row: Row = ???
    
    // if the column is not null:
    val strCol: String = row.stringOrNull("str_col")
    val intCol: Int = row.intOrZero("int_col")
    
    // if the column is nullable:
    val strCol: Option[String] = row.getString("str_col")
    val intCol: Option[java.lang.Integer] = row.getInteger("int_col")

    Then, the same in Java:

    import com.twitter.finagle.mysql.Row;
    import scala.Option;
    Row row = ...
    
    // if the column is not null:
    String strCol = row.stringOrNull("str_col");
    int intCol = row.intOrZero("int_col");
    
    // if the column is nullable:
    Option<String> strCol = row.getString("str_col");
    Option<Integer> intCol = row.getInteger("int_col");

    See also

    PreparedStatement.select

    Client.select

    Client.cursor

39.  case class ServerError(code: Short, sqlState: String, message: String) extends Exception with Product with Serializable

    A catch-all exception class for errors returned from the upstream MySQL server.

40.  case class ServerStatus(mask: Int) extends Product with Serializable

    Represents the ServerStatus as represented in EOF packets

    Represents the ServerStatus as represented in EOF packets

    mask

    the raw bit mask in the EOF packet

41.  trait Session extends AnyRef

    Explicitly manage the lifecycle of a MySQL session.

    Explicitly manage the lifecycle of a MySQL session.

    See also

    Client#session()

42.  case class ShortValue(s: Short) extends Value with Product with Serializable
43.  class SimpleCommandRequest extends CommandRequest

    Defines a request that encodes the command byte and associated data into a packet.

44.  case class StringValue(s: String) extends Value with Product with Serializable
45.  class TimestampValue extends Injectable[Timestamp] with Extractable[Timestamp]

    An injector/extractor of java.sql.Timestamp values.

46.  trait Transactions extends AnyRef
47.  class UnsupportedTypeException extends SQLNonTransientException with FailureFlags[UnsupportedTypeException]

    Indicates the requested column was for an unsupported type.

    Indicates the requested column was for an unsupported type. For example, asking for a string when the column is a tinyint.

48.  case class UseRequest(dbName: String) extends SimpleCommandRequest with Product with Serializable

    A UseRequest is used to change the default schema of the connection.

    A UseRequest is used to change the default schema of the connection. https://dev.mysql.com/doc/internals/en/com-init-db.html

49.  sealed trait Value extends AnyRef

    Defines a Value ADT that represents the domain of values received from a mysql server.

50.  class ValueSerializationException extends SQLNonTransientException with FailureFlags[ValueSerializationException]

    Thrown if unable to serialize a value of the column.

51.  sealed trait WithSql extends AnyRef

    Contains the SQL for a Request.