mapper

Type Members

1. trait AjaxEditableField[FieldType, OwnerType <: Mapper[OwnerType]] extends MappedField[FieldType, OwnerType]

   

   This trait can be added to existing Mapper fields to make them use AjaxUtils.editable for field display.

2. trait AscOrDesc extends AnyRef

   

3. trait BaseForeignKey extends BaseMappedField

   

   A trait that defines foreign key references

4. sealed trait BaseIndex[A <: Mapper[A]] extends AnyRef

   

5. trait BaseIndexedField extends BaseMappedField

   

6. trait BaseKeyedMapper extends BaseMapper

   

7. trait BaseLongKeyedMapper extends BaseKeyedMapper

   

8. trait BaseMappedField extends SelectableField with Bindable with MixableMappedField with Serializable

   

   The base (not Typed) trait that defines a field that is mapped to a column or more than 1 column (e.g., MappedPassword) in the database

9. trait BaseMapper extends FieldContainer

   

10. trait BaseMetaMapper extends AnyRef

    

11. trait BaseOwnedMappedField[OwnerType <: Mapper[OwnerType]] extends BaseMappedField

    

12. case class BoundedIndexField[A <: Mapper[A]](field: MappedField[String, A], len: Int) extends IndexItem[A] with Product with Serializable

    

13. sealed trait BoxedStringToken extends AnyRef

    

14. final case class ByList[O <: Mapper[O], T](field: MappedField[T, O], vals: Seq[T]) extends QueryParam[O] with Product with Serializable

    

15. final case class BySql[O <: Mapper[O]](query: String, checkedBy: IHaveValidatedThisSQL, params: Any*) extends QueryParam[O] with Product with Serializable

    

    Represents a query criterion using a parameterized SQL string.

    Represents a query criterion using a parameterized SQL string. Parameters are substituted in order. For Date/Time types, passing a java.util.Date will result in a Timestamp parameter. If you want a specific SQL Date/Time type, use the corresponding java.sql.Date, java.sql.Time, or java.sql.Timestamp classes.

16. trait CRUDify[KeyType, CrudType <: KeyedMapper[KeyType, CrudType]] extends Crudify

    

    This trait automatically adds CRUD (Create, read, update and delete) operations to an existing MetaMapper object.

    This trait automatically adds CRUD (Create, read, update and delete) operations to an existing MetaMapper object. Various methods can be overridden to customize which operations are available to a user and how things are displayed. For example, you can disable deletion of entities by overriding deleteMenuLoc to Empty.

    Note: Compilation will fail if you try to mix this into a Mapper instead of the associated MetaMapper. You have been warned.

17. final case class Cmp[O <: Mapper[O], T](field: MappedField[T, O], opr: OprEnum.Value, value: Box[T], otherField: Box[MappedField[T, O]], dbFunc: Box[String]) extends QueryParam[O] with Product with Serializable

    

18. type ConnectionIdentifier = util.ConnectionIdentifier

    

19. type ConnectionManager = db.ConnectionManager

    

20. trait CreatedTrait extends AnyRef

    

    A trait you can mix into a Mapper class that gives you a createdat column

21. trait CreatedUpdated extends CreatedTrait with UpdatedTrait

    

    Mix this trait into your Mapper instance to get createdAt and updatedAt fields.

22. trait DBIndexed extends BaseMappedField

    

    Mix this trait into a BaseMappedField and it will be indexed

23. type DBLogEntry = db.DBLogEntry

    

24. trait DefaultMillis extends TypedField[Long]

    

    Mix with MappedLong to give a default time of millis

25. final case class Distinct[O <: Mapper[O]]() extends QueryParam[O] with Product with Serializable

    

26. type DriverType = db.DriverType

    

27. class FieldFinder[T] extends AnyRef

    

28. final case class GenericIndex[A <: Mapper[A]](createFunc: (String, List[String]) ⇒ String, validated: IHaveValidatedThisSQL, columns: List[IndexItem[A]]) extends BaseIndex[A] with Product with Serializable

    

    Represents a generic user-specified index on the given columns.

    Represents a generic user-specified index on the given columns. The user provides a function to generate the SQL needed to create the index based on the table and columns. Validation is required since this is raw SQL being run on the database server.

29. trait HasApplyBoxString[T] extends AnyRef

    

30. class HasManyThrough[From <: KeyedMapper[ThroughType, From], To <: Mapper[To], Through <: Mapper[Through], ThroughType] extends LifecycleCallbacks

    

31. case class IHaveValidatedThisSQL(who: String, date: String) extends Product with Serializable

    

32. trait IdPK extends AnyRef

    

33. final case class Ignore[O <: Mapper[O]]() extends QueryParam[O] with Product with Serializable

    

34. final case class InRaw[TheType <: Mapper[TheType], T](field: MappedField[T, TheType], rawSql: String, checkedBy: IHaveValidatedThisSQL) extends QueryParam[TheType] with Product with Serializable

    

35. sealed abstract class InThing[OuterType <: Mapper[OuterType]] extends QueryParam[OuterType]

    

36. final case class Index[A <: Mapper[A]](columns: List[IndexItem[A]]) extends BaseIndex[A] with Product with Serializable

    

37. case class IndexField[A <: Mapper[A], T](field: MappedField[T, A]) extends IndexItem[A] with Product with Serializable

    

38. abstract class IndexItem[A <: Mapper[A]] extends AnyRef

    

39. trait IndexedField[O] extends BaseIndexedField

    

40. class KeyObfuscator extends AnyRef

    

41. trait KeyedMapper[KeyType, OwnerType <: KeyedMapper[KeyType, OwnerType]] extends Mapper[OwnerType] with BaseKeyedMapper

    

42. trait KeyedMetaMapper[Type, A <: KeyedMapper[Type, A]] extends MetaMapper[A] with KeyedMapper[Type, A]

    

43. trait LifecycleCallbacks extends AnyRef

    

44. trait LongCRUDify[CrudType <: KeyedMapper[Long, CrudType]] extends CRUDify[Long, CrudType]

    

    A specialization of CRUDify for LongKeyedMetaMappers.

45. trait LongKeyedMapper[OwnerType <: LongKeyedMapper[OwnerType]] extends KeyedMapper[Long, OwnerType] with BaseLongKeyedMapper

    

46. trait LongKeyedMetaMapper[A <: LongKeyedMapper[A]] extends KeyedMetaMapper[Long, A]

    

47. trait ManyToMany extends BaseKeyedMapper

    

    Add this trait to a Mapper to add support for many-to-many relationships

48. abstract class MappedBinary[T <: Mapper[T]] extends MappedField[Array[Byte], T]

    

49. abstract class MappedBirthYear[T <: Mapper[T]] extends MappedInt[T]

    

    A field that holds the birth year for the user

50. abstract class MappedBoolean[T <: Mapper[T]] extends MappedField[Boolean, T]

    

51. abstract class MappedCountry[T <: Mapper[T]] extends MappedEnum[T, Countries.type]

    

52. abstract class MappedDate[T <: Mapper[T]] extends MappedField[Date, T]

    

    Represents a date without hour, minute or second fields.

    Represents a date without hour, minute or second fields. The underlying type is java.util.Date to keep things simple, but be aware that the hour, minute and second values will most likely be discarded when this is saved to the database.

    See also

    MappedTime

    MappedDateTime

53. abstract class MappedDateTime[T <: Mapper[T]] extends MappedField[Date, T]

    

54. abstract class MappedDecimal[T <: Mapper[T]] extends MappedField[BigDecimal, T]

    

    A field that maps to a decimal value.

    A field that maps to a decimal value. Decimal precision and rounding are controlled via the context parameter. The default value is zero.

    Note:
    Using MathContext.UNLIMITED, whether explicitly or implicitly, means that no precision or scaling will be used for the SQL field definition; the default scale for DECIMAL is zero per the SQL standard, but the precision for DECIMAL is vendor-specific. For example, PostgreSQL uses maximum precision if it's not specified, but SQL Server uses a default precision of 18.

55. abstract class MappedDouble[T <: Mapper[T]] extends MappedField[Double, T]

    

56. abstract class MappedEmail[T <: Mapper[T]] extends MappedString[T]

    

57. abstract class MappedEnum[T <: Mapper[T], ENUM <: Enumeration] extends MappedField[mapper.MappedEnum.ENUM.Value, T]

    

    Warning: Do not use unnamed Enumerations with 2.8.1 as this will cause too many items to be displayed in the dropdown.

    Warning: Do not use unnamed Enumerations with 2.8.1 as this will cause too many items to be displayed in the dropdown.

    See https://issues.scala-lang.org/browse/SI-3687 for details

58. abstract class MappedEnumList[T <: Mapper[T], ENUM <: Enumeration] extends MappedField[Seq[mapper.MappedEnumList.ENUM.Value], T]

    

59. abstract class MappedFakeClob[T <: Mapper[T]] extends MappedField[String, T]

    

60. trait MappedField[FieldType, OwnerType <: Mapper[OwnerType]] extends TypedField[FieldType] with BaseOwnedMappedField[OwnerType] with FieldIdentifier with PSettableValueHolder[FieldType] with Equals

    

    The strongly typed field that's mapped to a column (or many columns) in the database.

    The strongly typed field that's mapped to a column (or many columns) in the database. FieldType is the type of the field and OwnerType is the Owner of the field

61. trait MappedForeignKey[KeyType, MyOwner <: Mapper[MyOwner], Other <: KeyedMapper[KeyType, Other]] extends MappedField[KeyType, MyOwner] with LifecycleCallbacks

    

    The Trait that defines a field that is mapped to a foreign key

62. abstract class MappedGender[T <: Mapper[T]] extends MappedEnum[T, Genders.type]

    

63. abstract class MappedInt[T <: Mapper[T]] extends MappedField[Int, T]

    

64. abstract class MappedIntIndex[T <: Mapper[T]] extends MappedInt[T] with IndexedField[Int]

    

65. abstract class MappedLocale[T <: Mapper[T]] extends MappedString[T]

    

66. abstract class MappedLong[T <: Mapper[T]] extends MappedField[Long, T]

    

67. abstract class MappedLongForeignKey[T <: Mapper[T], O <: KeyedMapper[Long, O]] extends MappedLong[T] with MappedForeignKey[Long, T, O] with BaseForeignKey

    

68. abstract class MappedLongIndex[T <: Mapper[T]] extends MappedLong[T] with IndexedField[Long]

    

69. trait MappedNullableField[NullableFieldType, OwnerType <: Mapper[OwnerType]] extends MappedField[Box[NullableFieldType], OwnerType]

    

    A Mapped field that is Nullable in the database.

    A Mapped field that is Nullable in the database. Will return Empty box for NULL values and Full for non-null values

70. abstract class MappedNullableLong[T <: Mapper[T]] extends MappedNullableField[Long, T]

    

71. abstract class MappedPassword[T <: Mapper[T]] extends MappedField[String, T]

    

72. abstract class MappedPoliteString[T <: Mapper[T]] extends MappedString[T]

    

    Just like MappedString, except it's defaultValue is "" and the length is auto-cropped to fit in the column

73. abstract class MappedPostalCode[T <: Mapper[T]] extends MappedString[T]

    

74. abstract class MappedString[T <: Mapper[T]] extends MappedField[String, T] with StringValidators with HasApplyBoxString[T]

    

75. abstract class MappedStringForeignKey[T <: Mapper[T], O <: KeyedMapper[String, O]] extends MappedString[T] with MappedForeignKey[String, T, O] with BaseForeignKey

    

76. abstract class MappedStringIndex[T <: Mapper[T]] extends MappedUniqueId[T] with IndexedField[String]

    

77. abstract class MappedText[T <: Mapper[T]] extends MappedField[String, T]

    

78. abstract class MappedTextarea[T <: Mapper[T]] extends MappedString[T]

    

79. abstract class MappedTime[T <: Mapper[T]] extends MappedField[Date, T]

    

    Represents a time with hour, minute and second fields.

    Represents a time with hour, minute and second fields. The underlying type is java.util.Date to keep things simple, but be aware that the date portion of the values will most likely be discarded when this is saved to the database.

    See also

    MappedDate

    MappedDateTime

80. abstract class MappedTimeZone[T <: Mapper[T]] extends MappedString[T]

    

81. abstract class MappedUniqueId[T <: Mapper[T]] extends MappedString[T]

    

82. trait Mapper[A <: Mapper[A]] extends BaseMapper with Serializable with SourceInfo

    

83. class MapperException extends Exception

    

84. final case class MaxRows[O <: Mapper[O]](max: Long) extends QueryParam[O] with Product with Serializable

    

85. trait MegaProtoUser[T <: MegaProtoUser[T]] extends ProtoUser[T]

    

    ProtoUser is bare bones.

    ProtoUser is bare bones. MetaProtoUser contains a bunch more fields including a validated flag, locale, timezone, etc.

86. trait MetaMapper[A <: Mapper[A]] extends BaseMetaMapper with Mapper[A]

    

87. trait MetaMegaProtoUser[ModelType <: MegaProtoUser[ModelType]] extends KeyedMetaMapper[Long, ModelType] with proto.ProtoUser

    

    Mix this trait into the the Mapper singleton for User and you get a bunch of user functionality including password reset, etc.

88. trait MetaProtoExtendedSession[T <: ProtoExtendedSession[T]] extends KeyedMetaMapper[Long, T]

    

89. trait MetaProtoTag[ModelType <: ProtoTag[ModelType]] extends KeyedMetaMapper[Long, ModelType]

    

90. trait MixableMappedField extends BaseField

    

    This is the supertrait of all traits that can be mixed into a MappedField.

    This is the supertrait of all traits that can be mixed into a MappedField. All methods should be abstract. They will be made concrete in implementations.

91. sealed trait NullOrder extends AnyRef

    

92. trait OneToMany[K, T <: KeyedMapper[K, T]] extends KeyedMapper[K, T]

    

    Add this trait to a Mapper for managed one-to-many support For example: class Contact extends LongKeyedMapper[Contact] with OneToMany[Long, Contact] { ...

    Add this trait to a Mapper for managed one-to-many support For example: class Contact extends LongKeyedMapper[Contact] with OneToMany[Long, Contact] { ... }

    K

    the type of the primary key

    T

    the mapper type

93. final case class OrderBy[O <: Mapper[O], T](field: MappedField[T, O], order: AscOrDesc, nullOrder: Box[NullOrder]) extends QueryParam[O] with Product with Serializable

    

94. final case class OrderBySql[O <: Mapper[O]](sql: String, checkedBy: IHaveValidatedThisSQL) extends QueryParam[O] with Product with Serializable

    

95. final case class PreCache[TheType <: Mapper[TheType], FieldType, OtherType <: KeyedMapper[FieldType, OtherType]](field: MappedForeignKey[FieldType, TheType, OtherType], deterministic: Boolean) extends QueryParam[TheType] with Product with Serializable

    

    This QueryParam can be put in a query and will cause the given foreign key field to be precached.

    This QueryParam can be put in a query and will cause the given foreign key field to be precached.

    field

    - the field to precache

    deterministic

    - true if the query is deterministic. Will be more efficient. false if the query is not deterministic. In this case, a SELECT * FROM FK_TABLE WHERE primary_key in (xxx) will be generated

96. trait ProtoExtendedSession[T <: ProtoExtendedSession[T]] extends KeyedMapper[Long, T]

    

97. abstract class ProtoTag[MyType <: ProtoTag[MyType]] extends KeyedMapper[Long, MyType] with Ordered[MyType]

    

98. trait ProtoUser[T <: ProtoUser[T]] extends KeyedMapper[Long, T] with UserIdAsString

    

    ProtoUser is a base class that gives you a "User" that has a first name, last name, email, etc.

99. sealed trait QueryParam[O <: Mapper[O]] extends AnyRef

    

100. trait SelectableField extends AnyRef

     

101. type StandardDBVendor = db.StandardDBVendor

     

102. final case class StartAt[O <: Mapper[O]](start: Long) extends QueryParam[O] with Product with Serializable

     

103. trait StopValidationOnError[T] extends (T) ⇒ List[FieldError]

     

     If this trait is mixed into a validation function, the validation for a field will stop if this validation function returns an error

104. type SuperConnection = db.SuperConnection

     

105. trait TypedField[FieldType] extends AnyRef

     

106. final case class UniqueIndex[A <: Mapper[A]](columns: List[IndexItem[A]]) extends BaseIndex[A] with Product with Serializable

     

     Represents a unique index on the given columns

107. trait UpdatedTrait extends AnyRef

     

     A trait you can mix into a Mapper class that gives you an updatedat column

108. trait UserIdAsString extends AnyRef

     

109. trait ValidateLength extends MixableMappedField

     

     Mix this trait into a MappedString and it will add maximum length validation to the MappedString