Database Design – Storing Hierarchical Templates in a Database

recursiontemplates

If this title is ambiguous, feel free to change it, I don't know how to put this in a one-liner.

Example:
Let's assume you have a html template which contains some custom tags, like <text_field />. We now create a page based on a template containing more of those custom tags. When a user wants to edit the page, he sees a text field. he can input things and save it.

This looks fairly easy to set up. You either have something like a template_positions table which stores the content of those fields.

Case:
I now have a bit of a blockade keeping things as simple as possible. Assume you have the same tag given in your example, and additionally, <layout> and <repeat> tags. Here's an example how they should be used:

<repeat>
  <layout name="image-left">
    <image /> <text_field />
  </layout>

  <layout name="image-right">
    <text_field /> <image />
  </layout>
</repeat>

We now have a block which can be repeated, obviously. This means: when creting/editing a page containing such a template block, I can choose between a layout image-left and image-right which then gets inserted as content element (where content for <image /> and <text_field /> gets stored). And because this is inside a <repeat>, content elements from the given layouts can be inserted multiple times.

How do you store this? Simply said, this could be stored with the same setup I've wrote in the example above, I just need to add a parent_id or something similiar to maintain a hierarchy. but I think I am missing something. At least the relation between an inserted content element and the origin/insertion point is missing. And what happens when I update the template file?

Do I have to give every custom tag that acts as editable part of a template an identifier that matches an identifier in the template to substitue them correctly?

Or can you think of a clean solution that might be better?

Best Answer

for your reference you can see Active directory implementation it is pretty much the same thing. but i would prefer you must use hierarchical database for this purpose.

you problem has solution is in No-SQL database. there are many databases with key value store schema under no-SQL umbrella. Relational databases are not design for this purpose although you can use them by having parent child relationships, insertion is fine but we will face difficulties while retrieving data.

if there is no restriction on changing the database you must go with that. but if you have no option other than SQL DB as you might have been using SQL for relational purposes it would be cumbersome to have separate DB base for this purpose only.

but again don't use SQL DB for this purpose.

Related Solutions

PHP – Creating a Custom PHP Template Engine

I'm not sure if I've understood your problem correctly or not, but that seems to me that Loading the data is your problem, not anything else related to your template engine, right?

If yes, my questions is, where are the other contents of your application? I mean where is the page content? Put the meta tags, titles, etc. just where you have the other data.

If you're storing your page content in the database, then add these meta tags (whatever) to your database, load them when you loading the page content and then just pass them to your template engine.

If you have static pages, then add something like these to each page, and later you can grab it and pass it to your template engine:

<?php
/* Sample.php */
$title = 'Sample Page';
$meta = 'whatever';
?>
<!-- Page Content -->
<h3>Welcome!</h3>
...

P.S. BTW, such an array of titles and meta tags is not an issue for a real-world web server.

C++ Template Function – How to Pass Iterators

The range to iterate over

The C++ standard library offers something of a canonical form here, accumulate;

template< class InputIt, class T >
T accumulate( InputIt first, InputIt last, T init );

It takes a range from first to last (excluding last) and adds each element in the range to the init value as an initial value. It will also infer the return type from the initial type.

If the an implementation of sum is required, I would advise the use of accumulate here as is. If not suitable, the function signature taking the range [first, last) is "normal" as it mirror the standard library.

Deduce the return type

To get the value type "behind" the iterator, std::iterator_traits, in particular the embedded type value_type can be used;

typedef typename std::iterator_traits<InputIt>::value_type Result;
// .. default initialise
Result sum = Result{}; // or Result() if earlier than C++11

Design choice

I would design the function to (variation of option 2);

Accept a range [first, last)
Use std::iterator_traits (that work with pointers as well) to infer the return type
Use the C++11 default initialisation to initialise the result

As follows:

template <class Iterator, class U = typename std::iterator_traits<Iterator>::value_type>
U sum(Iterator first, Iterator last)
{
    U sum = U{};
    for (auto it = first; it != last; ++it) {
        sum += *it;
    }
    return sum;
}

An alternative with reduced template arguments.

template <class Iterator>
typename std::iterator_traits<Iterator>::value_type sum(Iterator first, Iterator last)
{
    using U = typename std::iterator_traits<Iterator>::value_type;
    U sum = U{};
    for (auto it = first; it != last; ++it) {
        sum += *it;
    }
    return sum;
}

Best Answer

Related Solutions

PHP – Creating a Custom PHP Template Engine

C++ Template Function – How to Pass Iterators

Related Topic