1 #ifndef __creaImageIOSQLiteTreeHandler_h_INCLUDED__
2 #define __creaImageIOSQLiteTreeHandler_h_INCLUDED__
4 #include <creaImageIOTreeHandler.h>
15 //=======================================================================
16 /// Concrete TreeHandler which manages a Tree stored in a sqlite database
17 class SQLiteTreeHandler : virtual public TreeHandler
20 //====================================================================
21 /// Ctor with database file name
22 SQLiteTreeHandler(const std::string& filename);
24 virtual ~SQLiteTreeHandler();
25 //====================================================================
27 //====================================================================
28 /// Returns the sqlite db file name
29 const std::string& GetFileName() const { return mFileName; }
30 //====================================================================
32 //====================================================================
34 /// Is the 'source' readable ?
35 virtual bool IsReadable() { return true; }
36 /// Is the 'source' writable ?
37 virtual bool IsWritable() { return true; }
38 //====================================================================
41 //====================================================================
42 // INITIALIZATION / FINALIZATION
43 //====================================================================
45 //====================================================================
46 /// Opens an existing 'source'
47 // Default mode is read only
48 // If IsWritable and writable==true then opens in read/write mode
49 virtual bool Open(bool writable = false);
50 /// Closes the 'source'
52 /// Creates a new 'source'
53 // Default mode is read only
54 // If IsWritable and writable==true then opens in read/write mode
55 virtual bool Create(bool writable = false);
56 /// Destroys the 'source'
57 virtual bool Destroy();
58 //====================================================================
61 //====================================================================
63 //====================================================================
66 //====================================================================
67 /// Returns the number of children of the Node *WITHOUT LOADING THEM*
68 // REM : The Tree itself is a Node and asking for its number of
69 // children returns the number of children of level 1.
70 virtual unsigned int GetNumberOfChildren(tree::Node* n);
71 //====================================================================
73 //====================================================================
74 /// Returns the attribute requested. Useful for synchronization.
75 virtual void GetAttribute(std::string levelDescriptor,
76 std::string searchParam,
77 std::string searchVal,
80 //====================================================================
83 //====================================================================
84 /// Recursively loads the children of node 'parent' until maxlevel
86 // If parent == NULL or parent == tree then starts with the 'children' of
88 // Returns the total number of children loaded.
89 virtual int LoadChildren(tree::Node* parent, int maxlevel);
90 //====================================================================
92 //====================================================================
93 /// Unloads the Node and its descendants
94 // WITHOUT altering the source, e.g. the database
95 virtual void UnLoad(tree::Node* n);
96 ///====================================================================
98 //====================================================================
99 /// Returns the top level node id for the given search param and search value
100 virtual void GetTopLevelNodeId(const std::string& searchParam,
101 const std::string& searchValue,
102 std::string& parent_id);
103 ///====================================================================
105 //====================================================================
106 // WRITE METHODS : WORK ONLY IN WRITE MODE
107 //====================================================================
108 /// Adds a branch in the tree with the attributes provided
109 // returns the Level in the tree where the branch was connected
110 // (-1 for error, 0 for top level, etc. )
111 // Of course the branch is loaded on exit
112 virtual int AddBranch( const AttributeMapType& attr );
113 // Removes the node and its descendants
114 virtual bool Remove(tree::Node*);
115 // Sets an attribute of a Node
116 virtual bool SetAttribute(tree::Node*,
117 const std::string& key,
118 const std::string& value);
120 virtual void SetAttribute(const std::string& levelDescriptor,
121 const std::string& key,
122 const std::string& value,
123 const std::string& searchParam,
124 const std::string& searchVal);
125 //Deletes the tuple that matches the parameters given
126 virtual void DeleteTuple(std::string levelDescriptor, std::string key, std::string value);
128 //====================================================================
133 //======================================================================
134 /// Open the database
136 /// Import the Tree::Description from database (verifies the structure)
137 bool DBImportTreeDescription();
138 //======================================================================
139 //======================================================================
141 /// Creates a new database on disk and the tables
143 /// Appends to string s the SQL command to create the attributes of a given level
144 void SQLAppendAttributesDefinition(int level, std::string& s);
145 //======================================================================
147 //======================================================================
149 /// Returns the parent to which the branch defined by the attributes
150 // provided must be grafted
151 tree::Node* DBGetParent( const AttributeMapType& attr);
152 //======================================================================
154 //======================================================================
156 /// Loads the children of Node parent
157 // Can recurse to numberoflevels levels
158 // \return The total number of Node loaded (may be at different levels)
159 int DBLoadChildren( tree::Node* parent, int numberoflevels = 1);
160 //======================================================================
162 //======================================================================
164 /// Appends to string s the SQL command to set the attributes values
166 void SQLAppendAttributesValues(tree::Node* n, std::string& s);
167 //======================================================================
169 //======================================================================
171 /// Graft the branch defined by the attributes to the parent
172 void DBGraftToParent( tree::Node* parent, const AttributeMapType& attr);
173 //======================================================================
174 //======================================================================
176 /// Sets an attribute of a Node and updates the database
177 bool DBSetAttribute(tree::Node*,
178 const std::string& key,
179 const std::string& value);
180 //======================================================================
181 //======================================================================
182 /// Sets an attribute and updates the database
183 void DBSetAttribute(const std::string& levelDescriptor,
184 const std::string& key,
185 const std::string& value,
186 const std::string& searchParam,
187 const std::string& searchVal);
188 //======================================================================
189 //======================================================================
191 /// Inserts the Node in the database
192 void DBInsert(tree::Node* n);
193 //======================================================================
196 //======================================================================
198 /// Deletes the tuple that matches the value specified in the given key and that belongs to the given level
199 void DBDelete(std::string levelDescriptor, std::string key, std::string value);
200 //======================================================================
202 //======================================================================
204 /// Recursively Removes the nodes whose parent is given as a parameter
205 void DBRecursiveRemoveNode(tree::Node* node);
206 /// Recursively Removes the nodes found in the given level with the given parent id
207 void DBRecursiveRemoveNode(int level, std::string parentId);
209 //======================================================================
213 int DBQueryNumberOfChildren(tree::Node* n);
216 bool DBInsert(tree::Node* alien_node) ; //, UpdateSummary& summary);
219 std::string DBGetNodeId(tree::Node* node, const std::string& parent_id);
221 tree::Node* GetNodeFromTypeId(int level,
222 const std::string& id);
225 tree::Node* DBGetOrCreateNode(tree::Node* alien_node,
226 tree::Node* internal_parent,
227 std::string parentid,
228 std::string& created_id);
229 // UpdateSummary& summary);
231 tree::Node* DBGetOrCreateParent(tree::Node* alien_node,
232 std::string& parent_id);
233 // UpdateSummary& summary);
235 void DBRecursiveGetOrCreateNode(tree::Node* alien_node,
237 const std::string& parent_id);
238 // UpdateSummary& summary);
245 void BuildSQLFieldsValues(tree::Node* n,
249 tree::Node* GetChildrenLike(tree::Node* internal_parent,
250 tree::Node* alien_node);
255 /// The physical location associated to the DicomDatabase (directory, db file...)
256 std::string mFileName;
257 /// Is the DB writable ?
259 void SetWritable(bool w) { mWritable; }
260 bool GetWritable() const { return mWritable; }
268 bool operator< (const TypeId& o) const
270 return ((type<o.type) ||
271 ((type==o.type)&&id<o.id));
275 typedef std::map<TypeId,tree::Node*> TypeIdToNodeMapType;
276 TypeIdToNodeMapType mTypeIdToNodeMap;
279 // EO class SQLiteTreeHandler
280 //=======================================================================
283 } // EO namespace creaImageIO