Raw SQL vs OOP based queries (ORM)?

If you have no ( or limited ) experience with ORM, then it will take time to learn new API. Plus, you have to keep in mind, that the sacrifice the speed for 'magic'. For example, most ORMs will select wildcard '*' for fields, even when you just need list of titles from your Articles table.

And ORMs will aways fail in niche cases.

Most of ORMs out there ( the ones based on ActiveRecord pattern ) are extremely flawed from OOP's point of view. They create a tight coupling between your database structure and class/model.

You can think of ORMs as technical debt. It will make the start of project easier. But, as the code grows more complex, you will begin to encounter more and more problems caused by limitations in ORM's API. Eventually, you will have situations, when it is impossible to to do something with ORM and you will have to start writing SQL fragments and entires statements directly.

I would suggest to stay away from ORMs and implement a DataMapper pattern in your code. This will give you separation between your Domain Objects and the Database Access Layer.

For speed of development, I would go with an ORM, in particular if most data access is CRUD.

This way you don't have to also develop the SQL and write data access routines.

Scalability should't suffer, though you do need to understand what you are doing (you could hurt scalability with raw SQL as well).

If the project is either oriented : - data editing (as in viewing simple tables of data and editing them) - performance (as in designing the fastest algorithm to do a simple task)

Then you could go with direct sql commands in your code.

The thing you don't want to do, is do this if this is a large software, where you end up with many classes, and lot's of code. If you are in this case, and you scatter sql everywhere in your code, you will clearly regret it someday. You will have a hard time making changes to your domain model. Any modification would become really hard (except for adding functionalities or entites independant with the existing ones).

More information would be good, though, as : - What do you mean by frequent (how frequent) ? - What performance do you need ?

EDIT

It seems you're making some sort of CMS service. My bet is you don't want to start stuffing your code with SQL. @teresko's pattern suggestion seems interesting, seperating your application logic from the DB (which is always good), but giving the possiblity to customize every queries. Nonetheless, adding a layer that fills in memory objects can take more time than simply using the database result to write your page, but I don't think that small difference should matter in your case.

I'd suggest to choose a good pattern that seperates your business logique and dataAccess, like what @terekso suggested.

It depends a bit on timescale and your current knowledge of MySQL and ORM systems. If you don't have much time, just do whatever you know best, rather than wasting time learning a whole new set of code.

With more time, an ORM system like Doctrine or Propel can massively improve your development speed. When the schema is still changing a lot, you don't want to be spending a lot of time just rewriting queries. With an ORM system, it can be as simple as changing the schema file and clearing the cache.

Then when the design settles down, keep an eye on performance. If you do use ORM and your code is solid OOP, it's not too big an issue to migrate to SQL one query at a time.

That's the great thing about coding with OOP - a decision like this doesn't have to bind you forever.

I would always recommend using some form of ORM for your data access layer, as there has been a lot of time invested into the security aspect. That alone is a reason to not roll your own, unless you feel confident about your skills in protecting against SQL injection and other vulnerabilities.