/todo/db.todo

http://zoop.googlecode.com/ · Unknown · 135 lines · 135 code · 0 blank · 0 comment · 0 complexity · 2929abe2fd9c4db0fbc99587a5aee157 MD5 · raw file

  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