Type Members

1.  case class AlwaysOne[Schema[_]](children: List[Schema[_]]) extends ChildrenInSchema[Schema] with Product with Serializable
2.  trait AsDebugString[Schema[_]] extends AnyRef

   Annotations

   @implicitNotFound( ... )

3.  case class BatchDetails(batchSize: Int, index: Int) extends Product with Serializable
4.  sealed trait ChildArity extends AnyRef
5.  sealed trait ChildEntity extends OrmEntity
6.  sealed abstract class ChildrenInSchema[Schema[_]] extends AnyRef
7.  case class EntityAndFieldsAndPath[E <: OrmEntity](entity: E, fieldsAndPath: OrmGettersAndPath) extends Product with Serializable
8.  case class EntityAndPath[E <: OrmEntity](entity: E, paths: Array[List[Int]]) extends Product with Serializable
9.  case class EntityStrategy[X](mainEntityFn: (MainEntity) ⇒ X, childFn: (OrmEntity) ⇒ (ChildEntity) ⇒ X) extends Product with Serializable
10.  case class FanInOrmData[Context, T](t: T, name: String, idInParentData: GetKey, idForChild: GetKey, executeWhenMatch: (Context, T, List[Any]) ⇒ Context, data: Array[List[Any]], children: List[OrmData[Context]]) extends OrmData[Context] with Product with Serializable
11.  case class FanoutOrmData[Context, T](t: T, name: String, flyweightKey: FlyweightKey, executeWhenMatch: (Context, T, List[Any]) ⇒ Context, ar: Array[List[Any]], children: List[OrmData[Context]]) extends OrmData[Context] with Product with Serializable

    The data read from the database by ORM.

    The data read from the database by ORM. Later this should be replaceable by a cursor

    This is just for the 'numeric keys' story

    So important features:*

    • We need to process one to many tables and their children sensibly using the next mechanism
    • That means we will process all the things for my id, and then tell the children The data is sorted by id. Children are sorted by child Id Note that we need the id to by ordered... ANd that's awkward because we don't know how big the composible key is... suppose we have Keys1(a), Keys2(a,b), Keys3(a,b,c)... ah do we actually need the id or can we go flyweight?
12.  trait FastOrmSql extends AnyRef

    This is the layer of abstraction that needs to be rewritten for different databases.

    This is the layer of abstraction that needs to be rewritten for different databases. It's just a block of sql for each operation

13.  trait FastReader[T] extends (MainEntity) ⇒ (Int) ⇒ Stream[T]
14.  trait FastReaderDal extends AnyRef
15.  class FastReaderImpl[T] extends FastReader[T]
16.  case class FieldType[T](name: String, typeName: String, numericSort: Boolean)(implicit writeToJson: WriteToJson[T], getFromJson: GetFromJson[T], classTag: ClassTag[T]) extends Product with Serializable
17.  case class FieldTypeAndIndex[T](fieldType: FieldType[T], index: Int) extends Product with Serializable
18.  trait FindOrmEntityAndField[Schema[_]] extends AnyRef

    Asingle item in the schema might be in several places in the database (a key/a foreign key).

    Asingle item in the schema might be in several places in the database (a key/a foreign key). That item might be represented by multiple fields (e.g. a composite string, or a date where the date is stored in multiple fields

    here the list reflects the multiple places (keys/foreign keys) and the value getter itself understands about getting values

19.  trait FlyweightKey extends Comparator[List[Any]]
20.  class GetKey extends (List[Any]) ⇒ Any
21.  trait JsonToStream[T] extends AnyRef
22.  trait JsonToStreamFor[Schema[_]] extends AnyRef
23.  case class Key2(key1: FlyweightKey, key2: FlyweightKey) extends FlyweightKey with Product with Serializable
24.  case class KeyInt(leftIndex: Int, rightIndex: Int) extends FlyweightKey with Product with Serializable
25.  case class KeyString(leftIndex: Int, rightIndex: Int) extends FlyweightKey with Product with Serializable
26.  case class Keys(list: List[FieldType[_]]) extends Product with Serializable
27.  case class KeysAndIndex(list: List[(Int, FieldType[_])]) extends Product with Serializable
28.  case class MainEntity(tableName: TableName, alias: String, primaryKeyField: Keys, dataFields: List[FieldType[_]], children: List[ChildEntity]) extends OrmEntity with Product with Serializable
29.  case class MainOrmData[Context, T](t: T, name: String, contextMaker: () ⇒ Context, executeWhenMatch: (Context, T, List[Any]) ⇒ Context, ar: Array[List[Any]], children: List[OrmData[Context]]) extends Product with Serializable
30.  case class ManyToOneEntity(tableName: TableName, alias: String, primaryKeyField: Keys, idInParent: Keys, dataFields: List[FieldType[_]], children: List[ChildEntity]) extends SingleChild with Product with Serializable

    this is typically a look up reference.

    this is typically a look up reference. It is very similar to 'oneToZeroOneEntity' except that many of the parent are likely to share the same value. Thus it won't be in sync

31.  class NumericKeyPopulator[Schema[_]] extends (Array[Any], OrmEntity, List[Any]) ⇒ Array[Any]
32.  case class OneToManyEntity(tableName: TableName, alias: String, primaryKeyField: Keys, parentId: Keys, dataFields: List[FieldType[_]], children: List[ChildEntity]) extends ChildEntity with Product with Serializable
33.  case class OneToZeroOneEntity(tableName: TableName, alias: String, primaryKeyField: Keys, idInParent: Keys, dataFields: List[FieldType[_]], children: List[ChildEntity]) extends SingleChild with Product with Serializable

    This will have zero or one entries for each item in the parent.

    This will have zero or one entries for each item in the parent. It will be in 'step' with it... allowing cursors to advance together

34.  case class OrmBatchConfig(dataSource: DataSource, batchSize: Int) extends Product with Serializable
35.  trait OrmData[Context] extends AnyRef
36.  trait OrmDataFactory[MainT, T] extends AnyRef
37.  class OrmDataFactoryForMainEntity extends OrmDataFactory[MainEntity, OrmEntity]
38.  trait OrmEntity extends AnyRef
39.  trait OrmFactory[Schema[_]] extends AnyRef
40.  class OrmFactoryImpl[Schema[_]] extends OrmFactory[Schema]
41.  case class OrmGettersAndPath(ormValueGetters: Array[OrmValueGetter[_]], path: Array[Array[Int]], indicies: Array[Int]) extends Product with Serializable

    the orm getter is 'given this data from the database table what is the result.

    the orm getter is 'given this data from the database table what is the result. Path and index and where to put the result when we get it

42.  case class OrmGettersForThisRowAndPath(ormValueGetters: Array[OrmValueGetterForARow[_]], path: Array[Array[Int]], indicies: Array[Int]) extends Product with Serializable
43.  case class OrmKey[Schema[_], T](arity: ChildArity, key: String, t: Schema[T], path: List[Int], index: Int, children: OrmKeys[Schema]) extends Product with Serializable
44.  case class OrmKeys[Schema[_]](list: List[OrmKey[Schema, _]]) extends Product with Serializable

    The data in the database is based on tables The data we want in our json or objects is based on an objectgraph There has to be a mapping between the data in the database and the object graph: this is it

    The data in the database is based on tables The data we want in our json or objects is based on an objectgraph There has to be a mapping between the data in the database and the object graph: this is it

    Example: We have a schema: main: key1 table1/field1 key2 table2/field1 child: childKey1 table1/field2 As can be seen there isn't a simple mapping

    This heavily uses type classes, so you can use your own (perhaps existing) schema object. SchemaMapKey[Schema] -> This is how we know what keys exist and what children exist.

    Utility putJson: Very useful if you are using APIs because it writes to an outputstream and is much less garbage/memory intensive than turning to a string first toJson: Nicer interface than putJson

    Debugging: prettyPrint is really helpful for understanding the schema. It is intended for use in tests printArray prints the array of data retrieved from FastOrm in a way helpful for tests

45.  trait OrmKeysToJson[Schema[_]] extends AnyRef
46.  trait OrmMaker[T] extends (MainEntity) ⇒ (Map[OrmEntity, List[List[AnyRef]]]) ⇒ Stream[T]
47.  class OrmMakerForArrayAny[Schema[_]] extends OrmMaker[Array[Any]]
48.  class OrmMakerForArrayAnyUsingOrmData[Schema[_]] extends OrmMaker[Array[Any]]
49.  trait OrmStrategies extends AnyRef
50.  case class OrmValueGetter[T](tableName: TableName, fieldTypes: List[FieldType[_]])(implicit tx: OrmValueTransformer[T]) extends Product with Serializable
51.  case class OrmValueGetterForARow[T](tableName: TableName, fieldTypes: Array[FieldTypeAndIndex[_]], tx: OrmValueTransformer[T]) extends Product with Serializable
52.  trait OrmValueTransformer[T] extends (Array[FieldTypeAndIndex[_]], Array[Any]) ⇒ T
53.  trait Placeholder extends AnyRef
54.  case class SameIdEntity(tableName: TableName, alias: String, primaryKeyField: Keys, dataFields: List[FieldType[_]], children: List[ChildEntity]) extends SingleChild with Product with Serializable
55.  trait SchemaMapKey[Schema[_]] extends AnyRef

    THere is a schema of type Schema.

    THere is a schema of type Schema. Schema is not the data, is the structure of the data

    The type parameter is the type of the data in the field that the schema is pointing to. This is used for things like 'getting from database' and 'putting in json'.

    Because schemas hold other schemas, and I am not sure how to handle the schema object itself from a [T] perspective there is a fake T called Placeholder.

56.  trait SingleChild extends ChildEntity
57.  class StreamArrayAnyForOneEntity[Schema[_]] extends (Map[OrmEntity, List[List[AnyRef]]]) ⇒ Stream[Array[Any]]
58.  class StreamArrayAnyForOneEntity2[Schema[_]] extends (Map[OrmEntity, List[List[AnyRef]]]) ⇒ Stream[Array[Any]]
59.  case class TableAndFieldType[T](tableName: TableName, fieldType: FieldType[T]) extends Product with Serializable
60.  case class TableName(tableName: String, description: String) extends Product with Serializable
61.  case class TablesAndFieldsAndPaths(map: Map[TableName, OrmGettersAndPath]) extends Product with Serializable
62.  trait ToFieldType[T] extends AnyRef
63.  trait ToWritableForm[T] extends (T) ⇒ List[(OrmEntity, List[List[AnyRef]])]
64.  trait Write[T] extends AnyRef
65.  class WriteOrm extends AnyRef
66.  case class Zero[Schema[_]]() extends ChildrenInSchema[Schema] with Product with Serializable
67.  case class ZeroOrMore[Schema[_]](children: List[Schema[_]]) extends ChildrenInSchema[Schema] with Product with Serializable