Hola,
Creo que este es el lugar apropiado para publicar esto, porque aunque tiene que ver con bases de datos, tiene aún más que ver con OO.
Quizás algunos recuerden que hace un tiempo pedí comentarios sobre una librería de acceso a BD que había creado (la llamé
PHP5DBObject). Aunque en el momento no lo sabía con certeza, esta librería no es más que una implementación de un ActiveRecord o como otros le dicen: un ORM (Object-Relational Mapping).
La idea era hacer bastante transparente el acceso a BD para la carga de data en forma de objetos.
Pues bueno, he estado investigando más al respecto y me he encontrado con algunas cosas interesantes como los manejadores de base de datos orientados a objetos que por lo general están muy integrados con el lenguaje de programación y que se encargan de la persistencia de la información de los objetos.
Ahora bien, estos manejadores de BD han tenido una adopción bastante baja y creo que es principalmente porque funcionan bajo un paradigma bastante diferente al de las bases de datos relacionales. Algunas diferencias son:
1.- en las relacionales se trata con tablas, en las OO se trata con clases.
2.- en las relacionales, las relaciones entre datos se llevan con claves foráneas, etc, se utilizan tablas intermedias para las N a N, etc. En las OO, todo se hace por apuntadores.
3.- en las relacionales existe SQL para obtener la info que se desea y la BD se puede encargar de hacer parte de lógica con los SP, en las OO, sólo se encargan de la persistencia de los datos.
y otras más.
En fin, estoy queriendo evolucionar mi librería a algo más que un ORM (Object-Relational Mapping), me gustaría que fuera una capa de abstracción completa que permita la interacción con la base de datos como si esta fuera una base de datos orientada a objetos... pero a diferencia de las implementaciones típicas (casi todas en Java, no he conseguido ninguna en PHP... y tiene sentido por no ser un lenguaje fuertemente-tipeado... anglisismo de strongly-typed), quiero además que exista un SQL, para que sea un punto intermedio... por esto estoy comenzando con diseñar un lenguaje de query que permita la interacción con los datos (la verdadera transformación a BD no es muy relevante ahora)... y esto lo he apodado SOQL (Standard Object Query Language... ya que no hay ningún estándar... igual este sirve).
Por esto me gustaría mostrarles lo que llevo de SOQL y que me digan si les parece bien, comentarios, dudas, etc para ir aclarando ideas:
CREATE [ABSTRACT] CLASS class_name (
<property_definition> [, <property_definition>] ...
) [EXTENDS class_name] [IMPLEMENTS interface_name] [, IMPLEMENTS <interface_name>] ...;
CREATE INTERFACE interface_name (
<property_definition> [, <property_definition>] ...
) [EXTENDS interface_name];
DROP CLASS class_name;
DROP INTERFACE interface_name;
ALTER CLASS class_name <alter_definition> [, <alter_definition>] ...
CREATE INDEX ON class_name <index_definition>
DROP INDEX index_name
INSTANTIATE class_name [(property_name [, property_name] ...)] VALUES (value [, value] ...)
DELETE FROM class_name WHERE <where_condition>
UPDATE class_name SET property_name=value [, property_name=value] ... [ WHERE <where_condition>]
CAST FROM class_name WHERE <where_condition> TO class_name [WITH (property_name=value [, property_name=value] ...)]
SELECT [NON HIERARCHYCAL] [class_name|interface_name] WHERE <where_condition> [ORDER BY property_name [ASC|DESC] [, property_name [ASC|DESC]]... ] [LIMIT offset,numcols]
SHOW CLASSES
SHOW INTERFACES
SHOW INDEXES
Where:
property_definition:
<property_name> <property_type>[(<max_size>)] [NOT NULL]
property_type:
<simple_property> | <complex_property> | <vector_property>
simple_property:
boolean
| byte
| int
| long
| float
| double
| char(max_length)
| datetime
| binary(max_length)
complex_property:
<class_name>
| <interface_name>
vector_property:
vector(<simple_property> [, max_cardinality])
| vector(class_name [, max_cardinality])
| vector(interface_name [, max_cardinality])
| vector(<complex_property> [, max_cardinality])
index_definition:
<index_name> [NON HIERARCHYCAL] (property_name [, property_name] ...)
alter_definition:
ADD PROPERTY <property_name> <property_definition>
| DROP PROPERTY <property_name>
| MODIFY PROPERTY <property_name> <property_definition>
| ADD KEY <index_definition>
| DROP KEY <index_name>
| EXTENDS <class_name>
| ADD INTERFACE <interface_name>
| DROP INTERFACE <interface_name>
Qué les parece?
Se entiende lo que quiero hacer?
Saludos