Conceito de Banco de Dados

Pessoal, estou querendo desenvolver um conceito de banco de dados mais genérico possível. Então gostaria de opiniões, indicações de material de leitura, sobre esse conceito.

É o seguinte. Orientação à objetos. MVC, como fazer os Data Access Objects serem mais genéricos? Atualmente se eu tenho o model Cliente, eu faço um DAO Cliente. O que eu acho que é uma grande perda de tempo. Então estou há dias tentando imaginar uma forma melhor de fazer o relacionamento do objeto com banco de dados.

Mas para não perder tempo, vim pedir a opinião de vocês. A estrutura que desenvolvi segue o padrão abaixo:

Classe Abstrata Model - A classe que fará interação com o banco de dados, ela possui métodos abstratos para inserir, deletar, atualizar, capturar, procurar, e listar registros no banco de dados à partir do modelo.

Modelos - A classe de aplicação em si. Um exemplo a classe de Cliente. Ela teria os atributos privates, Nome, Sobrenome, e etc. Utiliza a estrutura de get e set para valores dos atributos. Ela extende a classe abstrata model.

Classes de Tipos - Classes que tratam os tipos, tanto na direção usuário->bd quanto bd->usuário. Por exemplo uma classe chamada TypeFloat. Ela teria métodos get e set, para setar os floats. Métodos monetiza, arredonda, cujos nomes já especificam para que serve.

Vamos à um exemplo de aplicação:

<?php

class AbstractModel {

	public function check () {
 // --- Faz checagem dos atributos da classe
	}

	public function insert () {
 // --- Faz insert caso check retorne true
	}

	public function find () {
 // --- Faz um like com os atributos que estão preenchidos da classe
	}

}

// --- Constante para indicar tipos, será utilizada abaixo

define('TYPE_STRING', 'TypeString');
define('TYPE_INTEGER', 'TypeInteger');

class TypeString {

	private $var;

	public function set ($var) {
 $this->var = (string)$var;
	}

	public function get () {
 return $this->var;
	}

}

class TypeInteger {

	private $var;

	public function set ($var) {
 $this->var = (int)$var;
	}

	public function get () {
 return $this->var;
	}

}

class Cliente extends AbstractModel {

// Valores tratados para o banco de dados
// Os índices devem ser os nomes do campo na tabela do banco de dados
public $fields = array(

 'nome' => NULL,
 'sobrenome' => NULL,
 'idade' => NULL
	);

	// Especifica qual o tipo do campo
	public $values = array (
 'nome' => TYPE_STRING,
 'sobrenome' => TYPE_STRING,
 'idade' => TYPE_INTEGER
	);

	// Especifica valores de tamanho para os campos
	// Strings: x/y ou x/ ou /y, onde x é o tamanho mínimo, e y o tamanho máximo, a ausência de um indica que não há limitação
	// Valores numéricos: x:y ou x: ou :y, onde x é o tamanho mínimo, e y o tamanho máximo, a ausência de um indica que não há limitação (aceita valores negativos)
	// Caso um campo não esteja especificado nenhum tipo de limitação é imposta
	public $sizes = array (
 'nome' => '3/30',
 'idade' => '18:'
	);

	public function __call ($metodo, $argumentos) {
 // Método genérico para verificar se foi chamado um get ou um set para algum dos campos especificados em fields
	}

}

/*****************************/
###### Exemplo de uso #######
/****************************/

$foo = new Cliente;

$idade = new TypeInteger;
$idade->set(23);

$foo->setIdade($idade);

$nome = new TypeString;
$nome->set('Fulano');
$sobrenome = new TypeString;
$sobrenome->set('da Silva');

$foo->setNome($nome);
$foo->setSobrenome($sobrenome);

// Agora entra a parte de aplicação do banco, utilizando a classe de modelo abstrato

if ($foo->check()) { // Faz a verificação de todas as limitações de tamanho, especificações de tipo
$foo->insert(); // Insere no banco
}

unset($foo);

#-----

$bar = new Cliente;

$nome = new TypeString;
$nome->set('Fulano');

$bar->setNome($nome);

if ($bar->find()) { // Busca cliente pelo nome e automaticamente, esse objeto já será montado com os valores do registro encontrado

	echo $bar->getIdade()->get();
}

?>

Então galerinha, o que acham? Pode dar certo? Coloquem casos possíveis para que eu possa pensar em um jeito de tratar com esse padrão de projeto.