Dave Dash

Database versus files for Images

2009-02-18T00:00:00-08:00

This is a dead topic for sure, but one of the bad web development habits I had picked up was that storing everything in a database made things easier.

I actually put some effort into thinking this through. For me it was a case of management. I didn't want to have to worry about two data stores for application-generated data. In otherwords, the data in the database was all generated via my web application (either by myself or others who worked on the product, or by end users). Having to also remember that there were select files as well seemed like a disaster.

Most frameworks, correctly assume you'll upload files to a filesystem. I never fully understood this until I thought about how I'd speed things up when the time comes to speed things up. Django forces you to think that way.

Almost from the start Django encourages you to:

Upload any binary content to the filesystem with pointers in a database
Have a separate server, or even machine serve static content.

Furthermore in a cached environment or even an environment that utilizes a CDN, putting static content in one spot, including user-generated content, was a big win.

I've been porting an app from symfony to django for some time, and I had been serving images via the database. Immediately when I switched to the filesystem I saw a huge benefit. Not just a drop in database connections, but overall "zippiness" in the site.

We'll see how well this performs in the real world, but I am quite sure that I learned my lesson.

Better than ORM Object Persistence

2007-12-20T00:00:00-08:00

After talking to people about the benefits and disadvantages of various ORMs... and reading up a little on non RDMBSs like Amazon SimpleDB I came to the realization that ORM is really a hack to get RDBMSs to work as a storage for objects.

I'm being liberal with the term hack. It really does work for a lot of situations, but it's not very elegant. The workflow is more or less this:

You create a database.
You create some objects
You define tables to store attributes of objects
You establish a mapping

There's a lot that goes into database definition. It would be nice to breakout from this line of thinking and do things a bit differently:

Create database
Save named (e.g. Person, Place, Log, Restaurant, Rating, Review) serialized objects to the database.

Let the database learn from the saving of the object how to define the type. In fact, it should be flexible and let us have mixmatched types, etc.

Let the database index everything, and keep the indexes up to date, but prioritize it based on usage. In other words if we usually query a database of Persons in order by a field called lastname, then make sure that index on lastname is always at hand. We should be able to query this data back out of storage based on how we stored it.

We should also be able to reach other objects in the database in a similar manner.

The key here is letting the database layer do the heavy-thinking about what to do with serialized data, versus having some middle layer take care of it.

...

so I might just be naive about data and databases. But if this idea is worthwhile and some database people can validate me, I'd be willing to work on it.

doctine and getState()

2007-07-10T00:00:00-07:00

[tags]doctrine, php, symfony, sfDoctrine, database,errors[/tags]

I tend to have models with a field called state. Doctrine offers a few ways of getting to the state field:

$obj->get('state');
$obj['state'];

$obj->getState() however conflicts with Doctrine_Record::getState() from which all objects inherit. Use one of the above alternatives.

Saving a file to a database using symfony and doctrine

2007-07-07T00:00:00-07:00

[tags]symfony, doctrine, database, uploads, wordpress, fixme[/tags]

I like to save content uploaded by website visitors to a database versus the file system. It makes it easy having the data all in one spot.

I tend to overcomplicate this process, so I wanted to write down the important steps:

In the template set multipart=true for the form. If you're using symfony helpers you can do this via:
```
 form_tag('@action', 'multipart=true')
```

Extract the binary data you want to store in the database in your action:

 $path = $this->getRequest()->getFilePath('my_file');
 $size = $this->getRequest()->getFileSize('my_file');
 $type = $this->getRequest()->getFileType('my_file');    
 $data = fread(f_open($path, "r"), $size);

 $myObject              = new MyObject();
 $myObject['file_data'] = $data;
 $myObject['file_size'] = $size;
 $myObject['mime_type'] = $type;
 $myObject->save();

Note: Wordpress is garbage so f_open should not have an underscore... what to do...

At least that's how we role with Doctrine. Note, Doctrine syntax is changing, and this may not be the most efficient way to create a new Doctrine Record in your application.