/todo/db.todo

  1+	lazy connections to the database
  2-	schemaless objects (exotic)
  3	-	have one table for objects with just (id, type) where type could be a class name
  4	-	have one table for fields with (object_id, field, value)
  5	-	have an index on (field, value) (so everything is indexed basically)
  6-	free memory from result sets after queries you've pulled all the data out
  7-	support for sequences
  8-	paginated result sets
  9-	pre-loading of data for many objects at a time
 10	-	run a sql statement, possibly excluding the field info
 11	-	look up the field info if necessary (if we used our own query language )
 12	-	create objects from the results
 13-	redundant file systems
 14	-	register two other file systems and make sure it gets written to both of them each time
 15	-	if either fails on a write
 16		-	throw an error
 17		-	log the error
 18	-	randomly choose one to read from
 19-	function to take two database connections and copy between them
 20	-	schema
 21	-	data
 22	-	settings
 23	-	copy or exclude only specific tables, settings, other objects, data ranges, etc
 24	-	copy linked data based on associations set up in DbObject or config files
 25-	cheap multi-master support
 26	-	make two connections
 27	-	run a transaction on both connections
 28	-	pre-commit both of them
 29	-	commit both of them
 30	-	document the fact that sequences between boxes won't be synced and your code will need to take that into account
 31	-	create a uuid generator in php to compensate
 32	-	build support into DbObject for this
 33-	cheap paritioning across boxes
 34	-	add support for DbObject to be tied to multiple servers
 35	-	have some sort of partitioning function to determine which one new rows go to
 36	-	for certain fields be able to use the partitioning function to know which box to get the data from
 37	-	in other situations query each box and aggregate the results
 38	-	make sure that DbObject doesn't try to do joins but rather always gets the objects from the correct box(es)
 39		-	maybe allow it to do joins if you have set it up so you know all the relevant data will be on the same box
 40-	enhance DbObject
 41	-	relationships
 42		+	one-to-one
 43		-	one-to-many (hasMany)
 44			-	allow you to auto-create x number of subordinate rows with given default values
 45			+	hasOne
 46			+	belongsTo
 47			+	basic functionality
 48			+	mapped field paramater
 49			-	allow you to specify an array for the mapped field paramter and have it organize it like the Sql*Map functions
 50		+	one-to-many
 51			-	allow you to auto-create x number of subordinate rows with given default values
 52			+	hasOne
 53			+	belongsTo
 54			+	basic functionality
 55			+	mapped field paramater
 56			-	allow you to specify an array for the mapped field paramter and have it organize it like the Sql*Map functions
 57		+	one-to-many
 58			-	allow you to auto-create x number of subordinate rows with given default values
 59			+	hasOne
 60			+	belongsTo
 61			+	basic functionality
 62			+	mapped field paramater
 63			-	allow you to specify an array for the mapped field paramter and have it organize it like the Sql*Map functions
 64		+	one-to-many
 65			-	allow you to auto-create x number of subordinate rows with given default values
 66			+	hasOne
 67			+	belongsTo
 68			+	basic functionality
 69			+	mapped field paramater
 70			-	allow you to specify an array for the mapped field paramter and have it organize it like the Sql*Map functions
 71		+	one-to-many
 72			-	allow you to auto-create x number of subordinate rows with given default values
 73			+	hasOne
 74			+	belongsTo
 75			+	basic functionality
 76			+	mapped field paramater
 77			-	allow you to specify an array for the mapped field paramter and have it organize it like the Sql*Map functions
 78		+	one-to-many
 79			-	allow you to auto-create x number of subordinate rows with given default values
 80		+	many-to-one
 81			+	belongsTo
 82		+	and many-to-many
 83			+	hasMany(through)
 84		-	distinguish between aggregate, ownership, and mapped relationships
 85		-	have a way to indicate that you want to pre-load the objects from these relationships
 86	-	figure out how to handle multiple database connections
 87		-	map by class
 88		-	map by function(classname, id) - returns connection
 89		-	map by object
 90	-	static functions
 91		-	functions
 92			-	findOne
 93			-	findMany
 94			-	findAll???
 95			-	createOne
 96			-	createMany
 97			-	getOne
 98			-	getMany
 99		-	handling
100			-	pass the name of the class name you are dealing with
101			-	have zap create stubs in each new subclass to let you call SubClassName::staticFunction(...);
102				-	use __classname__ or whatever it is so it can be identical in every subclass file
103				-	discontinue these if we have late static binding
104			-	try in every way to keep SQL out of the controllers and views
105				-	always create wrapper relationships, refiners, and wraper methods in the domain objects to keep SQL where it belongs
106	-	have a facility for creating often used queries within DbObject subclasses
107		-	a names set of paramaters to add to the where clause
108			-	examples
109			 	-	'currentManagerReview' => array('type' => self::managerType, 'period_id' => $gCurrentPeriod)
110				-	'currentManagerReview => "<this>.type = " . self::managerType . " and <this>.period_id = $gCurrentPeriod";
111	-	set up abstract methods called with DbObject::__construct
112		-	relate: use this to set up relationships
113		-	refine: use this to set up named queries
114	-	allow an object to be bound if it has all the values for any unique key on the table
115		-	how would you know which one to look up on?
116			-	primary key if it is there
117			-	first one it finds otherwise
118			-	validate that the other unique field sets match up
119-	evaluate doctrine
120	-	doctrine query language
121	-	how it handles prepared statements vs paramater escaping
122	-	connection management - how do we want to do it?
123-	support for options fields, you give it the table, the mapped field, and a list of options
124	-	add the field to the table
125	-	create the options table (you could combine many into one table, then you could skip this step it the table exists)
126	-	insert all the options into the table
127-	various tree handling libraries
128-	map reduce implementation
129-	distributed non-relational system
130	-	uuid for every entity
131	-	automatic schema creation based on objects or put each field in it's own row
132	-	manage all connections transparently
133	-	partition all data across all servers
134	-	make sure every row is in at least two places
135	-	make it possible to replicate across the internet