In the meantime a brand new side project idea is born.. All stats looking at the bleeding edge of the CMS/CMR/Framework panorama that I’ve encountered in the last month. None of them is really well suite for rapid application developement in  L(W)AMP environments. What is missing actually is a real visual IDE that fits into your browsers, and helps you deploy a consisten, secure, fast paced application starting from a simple set of tables/relations.

Something like the old visual basic stuff, but integrated with all the latest AJAX widgets and user experience. why should people still develop every single template/form/interface instead of simply concentrate in business logic?

so stay tuned, first lines of code are ready, as usual with prototype & usual suspects in the frontline.
I will publish one module/element/schema/idea per week, any help is greatly appreciated!!

here you can find it: too much code to explain, but if you don’t understand something, let me know


id | id_father | name | other datas
01 | 00 | root | ...
02 | 01 | sub node | ...


this kind of data structure is usually managed via recursion, and in web applications is useful to store site menu, product categories, file-system alike apps and so on.
The class i’m seeding here does all the dirty job giving you the possibility to

• use custom callback to modify the default behaviour [<ul><li> sequence]
• minimize/maximize function [for folder-like interfaces]
• navigation path serialization

those are the methods usually needed for day-to-day work with trees.
here you find all the code, but I’d like to poin out two things that [IMHO] really teach something to the average PHP programmer

• in the constructor 3 arrays are build as properties starting from the original array: arrayById, arrayByFather, arrayHasChild. I don’t know if it would be faster using array_find.. but once we’ve made the proper index association, ther’s no need for the original array to be parsed again.
• use of $$ for the callback function: not so many people knows this sintax, but it’s worth a try

the rest is really simple, and it’s well commented as well.

of course it fits perfectly with the standard output from dbmanager class presented here. Set up your table in an appropriate way, make your assocQuery call and use your tree in no time.

1. it’s very lightweight because it:
2. makes use of the “singleton” pattern, so you can start make a mess with patterns [if you've never do so]
3. ther’s soo much room for improvement
4. since I use it on an almost everyday basis anyother of my seeds will use it, so get used to it!

When you deal with mysql connections you should keep in mind that every single connection takes its load or system resources, and if you don’t pay attentio you could easily end up into a ‘too many connections‘ error and a faulty applications.
The very first solutions would be trying to use persistent connections, and this works very well on the mysql side: every page builds just one connection. The singleton pattern is chosen here because off it has a very low footprint into system resources: this means that you free more resources for the rest of your crappy code.

After creating your dbmanager Object, you have to dbmanager::connect giving host, user, pwd, db as always. from now on, you will have basically two methods:

dbmanager::assocQuery($sql) and dbmanager::sqlQuery($sql)

those two methods just query the database with the given query [there are also some nice counters if you wanna know how many querys ar made for every page you build].
The nice thing about dbmanager::assocQuery($sql) is how the result is returned: an associative array with fieldnames as keys: that’s really useful when you then have to cycle through your recordset and build tables, analyze data and so on.


$db=new dbconnection("mysql");
$db->connect($host,$login,$password,$database);
$recordset=$db->assocQuery("SELECT * FROM TABLENAME WHERE CONDITIONS...");
foreach($recordset as $record){
    // here goes your code
    }

very straightforward, isn’t it???

uh.. the code is here


function __autoload($class){
    # autoloading of a class #
    if (file_exists("classes/class.".$class.".php"))
    include_once("classes/class.".$class.".php");
    else print "Failed to auto-load classes/class.{$class}.php";
    }


it’s a little snippet of PHP code who take care of autoloading a class when you try to use it and the relevant definition file hasn’t still been loaded.
As you can see, if you use a bit of naming convention and a solid file structure it could resolve many problems, expecially the neverending list of file inclusions at the beginning of your scripts.

Maybe some tweaks should be necessary to solve securiti issues, if you have any…