mysql

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. http://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

    PreparedStatement for eager processing of Rows.

    Client.cursor(String

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. http://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 Handshake(username: Option[String] = None, password: Option[String] = None, database: Option[String] = None, clientCap: Capability = Capability.baseCap, charset: Short = Utf8_general_ci, enableFoundRows: Boolean = true, maxPacketSize: StorageUnit = 1.gigabyte) extends (HandshakeInit) ⇒ Try[HandshakeResponse] with Product with Serializable

    

    Bridges a server handshake (HandshakeInit) with a client handshake (HandshakeResponse) using the given parameters.

    Bridges a server handshake (HandshakeInit) with a client handshake (HandshakeResponse) using the given parameters. This facilitates the connection phase of the mysql protocol.

    username

    MySQL username used to login.

    password

    MySQL password used to login.

    database

    initial database to use for the session.

    clientCap

    The capability this client has.

    charset

    default character established with the server.

    enableFoundRows

    if the server should return the number of found (matched) rows, not the number of changed rows for UPDATE and INSERT ... ON DUPLICATE KEY UPDATE statements.

    maxPacketSize

    max size of a command packet that the client intends to send to the server. The largest possible packet that can be transmitted to or from a MySQL 5.5 server or client is 1GB.

    returns

    A Try[HandshakeResponse] that encodes incompatibility with the server.

22. case class HandshakeInit(protocol: Byte, version: String, threadId: Int, salt: Array[Byte], serverCap: Capability, charset: Short, status: Short) extends Result with Product with Serializable

    

23. case class HandshakeResponse(username: Option[String], password: Option[String], database: Option[String], clientCap: Capability, salt: Array[Byte], serverCap: Capability, charset: Short, maxPacketSize: Int) extends Request with Product with Serializable

    

    Client response sent during connection phase.

    Client response sent during connection phase. Responsible for encoding credentials used to authenticate a session. http://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::HandshakeResponse41

24. class IncompatibleServerError extends Exception

    

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

25. case class IntValue(i: Int) extends Value with Product with Serializable

    

26. sealed trait IsolationLevel extends AnyRef

    

27. case class LongValue(l: Long) extends Value with Product with Serializable

    

28. case class LostSyncException(underlying: Throwable) extends RuntimeException with Product with Serializable

    

29. 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.

30. 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");

31. 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

    

32. 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. http://dev.mysql.com/doc/internals/en/com-stmt-prepare.html

33. 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

    CursoredStatement for a lazy stream of Rows.

    Client.prepare(String)

34. 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. http://dev.mysql.com/doc/internals/en/com-query.html

35. 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.

36. sealed trait Request extends AnyRef

    

37. sealed trait Result extends AnyRef

    

38. case class ResultSet(fields: Seq[Field], rows: Seq[Row]) extends Result with Product with Serializable

    

39. 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

40. 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

    Client.cursor

    Client.select

    PreparedStatement.select

41. 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.

42. 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

43. case class ShortValue(s: Short) extends Value with Product with Serializable

    

44. class SimpleCommandRequest extends CommandRequest

    

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

45. case class StringValue(s: String) extends Value with Product with Serializable

    

46. class TimestampValue extends Injectable[Timestamp] with Extractable[Timestamp]

    

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

47. trait Transactions extends AnyRef

    

48. 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.

49. 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. http://dev.mysql.com/doc/internals/en/com-init-db.html

50. sealed trait Value extends AnyRef

    

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

51. sealed trait WithSql extends AnyRef

    

    Contains the SQL for a Request.