/
ROADMAP.txt
126 lines (86 loc) · 2.96 KB
/
ROADMAP.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
git-db abstract classes
-----------------------
These classes will eventually allow for loading of rows from a Git DB
store with no magic. They are the simple representations of the data
and store, but don't try to do anything fancy meta-wise.
Git::DB::ColumnFormat::*
Git::DB::Class
Git::DB::Attr
Git::DB::Type
Git::DB::Key
Git::DB::Schema
On top of these abstract classes can be built the CRUD feature set,
and potentially XS porting, or even a C version.
* bootstrapping the schema objects into the store with a fixed M2
* dump from relational databases:
** 'dump' facility for Pg/DBI `git db backup`
** 'copy in/insert' basic functionality
* restore to relational databases:
** 'restore' facility for Pg/DBI `git db restore`
** 'copy out/select' basic functionality
*** select: full scan
* basic integrity checking:
git db check --data
☝ MILESTONE: 1st Normal Form
* selects using ASTs (SQL::Abstract queries via JSON)
** simple:
*** select: query by ID
* 'insert' features
** honouring key constraints
git db check --constraints
☝ MILESTONE: 2nd normal form
* 'delete' features
** honouring key constraints
** cascade delete
* 'update' & 'upsert'
** 'redump' facility (incremental dump) for Pg/DBI
* transaction logic: `git db commit`
** git index mapping: `git db begin shared`
** marking and recording read rows
** merge logic
git db merge
git db check --merges
☝ MILESTONE: audited, decentralised operation
* integration with SRS cluster logic system
☝ MILESTONE: audited, decentralised CAP - P support
* advanced selects:
** select methods:
*** index scans
** joins:
*** cartesian products
*** nested loop
*** hash merge
* schema logic
** detecting schema changes
** programs which convert schemas
** merging in the face of schema changes
git-db metaclass traits
-----------------------
These are the metaclass traits you mix in to get Git::DB::Class
objects generated from your Perl classes. ie, re-use the
normalization that you already do with Moose attributes for use in the
storage representation.
This direction is certainly more of a higher order magic-land.
Metaprogramming.
There are a number of yaks to be shaved along this road.
MooseX::NaturalKey - needs to be trait-ified
MooseX::UniqueKey - another constraint-like module
MooseX::ForeignKey - providing relational collection attributes
relational meeting OO/heirarchical/whatever
-------------------------------------------
This avenue of development is where certain problems will be shoved
for later categorisation.
* JSPON-style links
mapping arbitrary back-references and reference counting
garbage collection
all that other insane stuff people left behind with relational
databases :)
git db check --references
* Polymorphic retrieval
considerations
primary key variability
'horizontal' vs 'vertical' mapping
* mapping ideas:
array primary keys (nested directories a la DNS)
submodule trees: hiding portions of the data
* scaling to mapreduce size?