-
+Offset collection is the same as immediate collection with the difference that it uses database provided limiting of queries.
+
+Example queries:
+SELECT id, name, type, created FROM user LIMIT 5
+SELECT id, name, type, created FROM user LIMIT 5 OFFSET 5
+SELECT id, name, type, created FROM user LIMIT 5 OFFSET 10
+[ ... ]
FROM",$l); + $l = str_replace("LEFT JOIN","
LEFT JOIN",$l); + $l = str_replace("WHERE","
WHERE",$l); + $l = str_replace("AS","AS",$l); + $l = str_replace("ON","ON",$l); + $l = str_replace("ORDER BY","ORDER BY",$l); + $l = str_replace("LIMIT","LIMIT",$l); + $l = str_replace("OFFSET","OFFSET",$l); + $l = str_replace(" ","
"; + print $l."
"; + +} + +?> diff --git a/manual/docs/Basic Components - Query - Introduction.php b/manual/docs/Basic Components - Query - Introduction.php new file mode 100644 index 000000000..2a80f0189 --- /dev/null +++ b/manual/docs/Basic Components - Query - Introduction.php @@ -0,0 +1,8 @@ +DQL (Doctrine Query Language) is a object query language which allows +you to find objects. DQL understands things like object relationships, polymorphism and +inheritance (including column aggregation inheritance). +
+So instead of writing lots of SQL inner and outer joins, unions and subselects yourself, +you can write simple DQL queries where relationships are being referenced with dot-notation. +
+You can execute DQL queries with Doctrine_Session::query() method. diff --git a/manual/docs/Basic Components - Query - Method overloading.php b/manual/docs/Basic Components - Query - Method overloading.php new file mode 100644 index 000000000..1dfc1c89e --- /dev/null +++ b/manual/docs/Basic Components - Query - Method overloading.php @@ -0,0 +1 @@ +You can overload the query object by calling the dql query parts as methods. diff --git a/manual/docs/Basic Components - Query - ORDER BY - sorting query results.php b/manual/docs/Basic Components - Query - ORDER BY - sorting query results.php new file mode 100644 index 000000000..642ec5d6e --- /dev/null +++ b/manual/docs/Basic Components - Query - ORDER BY - sorting query results.php @@ -0,0 +1 @@ +ORDER BY - part works in much same way as SQL ORDER BY. diff --git a/manual/docs/Basic Components - Query - Relation operators.php b/manual/docs/Basic Components - Query - Relation operators.php new file mode 100644 index 000000000..1ebde18d7 --- /dev/null +++ b/manual/docs/Basic Components - Query - Relation operators.php @@ -0,0 +1,7 @@ +Doctrine provides two relation operators: '.' aka dot and ':' aka colon. +
+The dot-operator is used for SQL LEFT JOINs and the colon-operator is used +for SQL INNER JOINs. Basically you should use dot operator if you want for example +to select all users and their phonenumbers AND it doesn't matter if the users actually have any phonenumbers. +
+On the other hand if you want to select only the users which actually have phonenumbers you should use the colon-operator. diff --git a/manual/docs/Basic Components - Record - Accessing properties.php b/manual/docs/Basic Components - Record - Accessing properties.php new file mode 100644 index 000000000..a56f41558 --- /dev/null +++ b/manual/docs/Basic Components - Record - Accessing properties.php @@ -0,0 +1,3 @@ +You can retrieve existing objects (database rows) with Doctrine_Table or Doctrine_Session. +Doctrine_Table provides simple methods like findBySql, findAll and find for finding objects whereas +Doctrine_Session provides complete OQL API for retrieving objects (see chapter 9). diff --git a/manual/docs/Basic Components - Record - Adding records.php b/manual/docs/Basic Components - Record - Adding records.php new file mode 100644 index 000000000..b766d4b09 --- /dev/null +++ b/manual/docs/Basic Components - Record - Adding records.php @@ -0,0 +1,3 @@ +There are three possible ways to access the properties of a record (fields of database row). +You can use overloading, ArrayAccess interface or simply Doctrine_Record::get() method. +Doctrine_Record objects have always all properties in lowercase. diff --git a/manual/docs/Basic Components - Record - Creating new records.php b/manual/docs/Basic Components - Record - Creating new records.php new file mode 100644 index 000000000..d4843ba8f --- /dev/null +++ b/manual/docs/Basic Components - Record - Creating new records.php @@ -0,0 +1,3 @@ +There are couple of ways for creating new records. Propably the easiest is using +native php new -operator. The other ways are calling Doctrine_Table::create() or Doctrine_Session::create(). +The last two exists only for backward compatibility. The recommended way of creating new objects is the new operator. diff --git a/manual/docs/Basic Components - Record - Deleting records.php b/manual/docs/Basic Components - Record - Deleting records.php new file mode 100644 index 000000000..cc8b3883e --- /dev/null +++ b/manual/docs/Basic Components - Record - Deleting records.php @@ -0,0 +1,2 @@ +Deleting records in Doctrine is handled by Doctrine_Record::delete(), Doctrine_Collection::delete() and +Doctrine_Session::delete() methods. diff --git a/manual/docs/Basic Components - Record - Getting object copy.php b/manual/docs/Basic Components - Record - Getting object copy.php new file mode 100644 index 000000000..89858805f --- /dev/null +++ b/manual/docs/Basic Components - Record - Getting object copy.php @@ -0,0 +1,2 @@ +Sometimes you may want to get a copy of your object (a new object with all properties copied). +Doctrine provides a simple method for this: Doctrine_Record::copy(). diff --git a/manual/docs/Basic Components - Record - Getting record state.php b/manual/docs/Basic Components - Record - Getting record state.php new file mode 100644 index 000000000..dc9a5c9d3 --- /dev/null +++ b/manual/docs/Basic Components - Record - Getting record state.php @@ -0,0 +1,7 @@ +Every Doctrine_Record has a state. First of all record can be transient or persistent. +Every record that is retrieved from database is persistent and every newly created record is transient. +If a Doctrine_Record is retrieved from database but the only loaded property is its primary key, then this record +has a state called proxy. +
+Every transient and persistent Doctrine_Record is either clean or dirty. Doctrine_Record is clean when none of its properties are changed and +dirty when atleast one of its properties has changed. diff --git a/manual/docs/Basic Components - Record - Retrieving existing records.php b/manual/docs/Basic Components - Record - Retrieving existing records.php new file mode 100644 index 000000000..ca7639fa7 --- /dev/null +++ b/manual/docs/Basic Components - Record - Retrieving existing records.php @@ -0,0 +1,3 @@ +Doctrine provides many ways for record retrieval. The fastest ways for retrieving existing records +are the finder methods provided by Doctrine_Table. If you need to use more complex queries take a look at +DQL API and Doctrine_Session::query method. diff --git a/manual/docs/Basic Components - Record - Serializing.php b/manual/docs/Basic Components - Record - Serializing.php new file mode 100644 index 000000000..45a642d0c --- /dev/null +++ b/manual/docs/Basic Components - Record - Serializing.php @@ -0,0 +1,2 @@ +Sometimes you may want to serialize your record objects (possibly for caching purposes). Records can be serialized, +but remember: Doctrine cleans all relations, before doing this. So remember to persist your objects into database before serializing them. diff --git a/manual/docs/Basic Components - Record - Updating records.php b/manual/docs/Basic Components - Record - Updating records.php new file mode 100644 index 000000000..f9415397f --- /dev/null +++ b/manual/docs/Basic Components - Record - Updating records.php @@ -0,0 +1,3 @@ +Updating objects is very easy, you just call the Doctrine_Record::save() method. The other way +(perhaps even easier) is to call Doctrine_Session::flush() which saves all objects. It should be noted though +that flushing is a much heavier operation than just calling save method. diff --git a/manual/docs/Basic Components - Session - Flushing the session.php b/manual/docs/Basic Components - Session - Flushing the session.php new file mode 100644 index 000000000..c3888aada --- /dev/null +++ b/manual/docs/Basic Components - Session - Flushing the session.php @@ -0,0 +1,2 @@ +Creating new record (database row) is very easy. You can either use the Doctrine_Session::create() or Doctrine_Table::create() +method to do this or just simple use the new operator. diff --git a/manual/docs/Basic Components - Session - Getting a table object.php b/manual/docs/Basic Components - Session - Getting a table object.php new file mode 100644 index 000000000..0795c7d9b --- /dev/null +++ b/manual/docs/Basic Components - Session - Getting a table object.php @@ -0,0 +1 @@ +In order to get table object for specified record just call Doctrine_Record::getTable() or Doctrine_Session::getTable(). diff --git a/manual/docs/Basic Components - Session - Getting session state.php b/manual/docs/Basic Components - Session - Getting session state.php new file mode 100644 index 000000000..f6ae741b9 --- /dev/null +++ b/manual/docs/Basic Components - Session - Getting session state.php @@ -0,0 +1,2 @@ +Session state gives you information about how active session currently is. You can get the current state +by calling Doctrine_Session::getState(). diff --git a/manual/docs/Basic Components - Table - Custom finders.php b/manual/docs/Basic Components - Table - Custom finders.php new file mode 100644 index 000000000..fb595a24e --- /dev/null +++ b/manual/docs/Basic Components - Table - Custom finders.php @@ -0,0 +1,2 @@ +You can add custom finder methods to your custom table object. These finder methods may use fast +Doctrine_Table finder methods or DQL API (Doctrine_Session::query()). diff --git a/manual/docs/Basic Components - Table - Custom table classes.php b/manual/docs/Basic Components - Table - Custom table classes.php new file mode 100644 index 000000000..f267c2ac9 --- /dev/null +++ b/manual/docs/Basic Components - Table - Custom table classes.php @@ -0,0 +1,2 @@ +Adding custom table classes is very easy. Only thing you need to do is name the classes as [componentName]Table and make them +inherit Doctrine_Table. diff --git a/manual/docs/Basic Components - Table - Finder methods.php b/manual/docs/Basic Components - Table - Finder methods.php new file mode 100644 index 000000000..a93e45cd9 --- /dev/null +++ b/manual/docs/Basic Components - Table - Finder methods.php @@ -0,0 +1,2 @@ +Doctrine_Table provides basic finder methods. These finder methods are very fast and should be used if you only need to fetch +data from one database table. If you need queries that use several components (database tables) use Doctrine_Session::query(). diff --git a/manual/docs/Basic components - Exceptions - List of exceptions.php b/manual/docs/Basic components - Exceptions - List of exceptions.php new file mode 100644 index 000000000..a3a7b55fa --- /dev/null +++ b/manual/docs/Basic components - Exceptions - List of exceptions.php @@ -0,0 +1,24 @@ +
+InvalidKeyException + +Doctrine_Exception + +DQLException + +Doctrine_PrimaryKey_Exception thrown when Doctrine_Record is loaded and there is no primary key field + +Doctrine_Refresh_Exception thrown when Doctrine_Record is refreshed and the refreshed primary key doens't match the old one + +Doctrine_Find_Exception thrown when user tries to find a Doctrine_Record for given primary key and that object is not found + +Doctrine_Naming_Exception thrown when user defined Doctrine_Table is badly named + + +Doctrine_Session_Exception thrown when user tries to get the current + session and there are no open sessions + +Doctrine_Table_Exception thrown when user tries to initialize a new instance of Doctrine_Table, + while there already exists an instance of that factory + +Doctrine_Mapping_Exception thrown when user tries to get a foreign key object but the mapping is not done right +diff --git a/manual/docs/Cache - Configuration.php b/manual/docs/Cache - Configuration.php new file mode 100644 index 000000000..12b5d869b --- /dev/null +++ b/manual/docs/Cache - Configuration.php @@ -0,0 +1,26 @@ +There are couple of availible Cache attributes on Doctrine: +
-
+
- Doctrine::ATTR_CACHE_SIZE
+
-
+
- Defines which cache container Doctrine uses +
- Possible values: Doctrine::CACHE_* (for example Doctrine::CACHE_FILE) +
- Doctrine::ATTR_CACHE_DIR
+
-
+
- cache directory where .cache files are saved +
- the default cache dir is %ROOT%/cachedir, where + %ROOT% is automatically converted to doctrine root dir +
- Doctrine::ATTR_CACHE_SLAM
+
-
+
- On very busy servers whenever you start the server or modify files you can create a race of many processes all trying to cache the same file at the same time. This option sets the percentage of processes that will skip trying to cache an uncached file. Or think of it as the probability of a single process to skip caching. For example, setting apc.slam_defense to 75 would mean that there is a 75% chance that the process will not cache an uncached file. So, the higher the setting the greater the defense against cache slams. Setting this to 0 disables this feature +
- Doctrine::ATTR_CACHE_SIZE
+
-
+
- Cache size attribute +
- Doctrine::ATTR_CACHE_TTL
+
-
+
- How often the cache is cleaned +
+
|
+1. Every Doctrine_Table has its own cache directory. The default is cache/componentname/. All the cache files are saved into that directory.
+The format of each cache file is [primarykey].cache.
+ +2. When retrieving records from the database doctrine always tries to hit the cache first. + +3. If a record (Doctrine_Record) is retrieved from database or inserted into database it will be saved into cache. + +4. When a Data Access Object is deleted or updated it will be deleted from the cache + |
+Now one might wonder that this kind of solution won't work since eventually the cache will be a copy of database! +So doctrine does the following things to ensure the cache won't get too big: +
+
|
+
+1. Every time a cache file is accessed the id of that record will be added into the $fetched property of Doctrine_Cache
+ +2. At the end of each script the Doctrine_Cache destructor will write all these primary keys at the end of a stats.cache file + +3. Doctrine does propabalistic cache cleaning. The default interval is 200 page loads (= 200 constructed Doctrine_Managers). Basically this means +that the average number of page loads between cache cleans is 200. + +4. On every cache clean stats.cache files are being read and the least accessed cache files +(cache files that have the smallest id occurance in the stats file) are then deleted. +For example if the cache size is set to 200 and the number of files in cache is 300, then 100 least accessed files are being deleted. +Doctrine also clears every stats.cache file. + + |
+So for every 199 fast page loads there is one page load which suffers a little overhead from the cache cleaning operation. diff --git a/manual/docs/Configuration - Levels of configuration.php b/manual/docs/Configuration - Levels of configuration.php new file mode 100644 index 000000000..6b8bc07a2 --- /dev/null +++ b/manual/docs/Configuration - Levels of configuration.php @@ -0,0 +1,18 @@ +Doctrine has a three-level configuration structure. You can set configuration attributes in global, session and table level. +If the same attribute is set on both lower level and upper level, the uppermost attribute will always be used. So for example +if user first sets default fetchmode in global level to Doctrine::FETCH_BATCH and then sets 'example' table fetchmode to Doctrine::FETCH_LAZY, +the lazy fetching strategy will be used whenever the records of 'example' table are being fetched. + +
+
-
+ The attributes set in global level will affect every session and every table in each session.
+
-
+ The attributes set in session level will take effect on each table in that session.
+
-
+ The attributes set in table level will take effect only on that table.
+
+In the beginning of your every script you can put: diff --git a/manual/docs/Getting started - Requirements.php b/manual/docs/Getting started - Requirements.php new file mode 100644 index 000000000..3fcc3431f --- /dev/null +++ b/manual/docs/Getting started - Requirements.php @@ -0,0 +1,3 @@ +Doctrine requires PHP >= 5.1. it doesn't require any external libraries. +For database abstraction Doctrine uses PDO which is bundled with php by default. Doctrine also requires a little +adodb-hack for table creation, which comes with doctrine as of beta4. diff --git a/manual/docs/Getting started - Setting table definition - Constraints and validators.php b/manual/docs/Getting started - Setting table definition - Constraints and validators.php new file mode 100644 index 000000000..4063fc442 --- /dev/null +++ b/manual/docs/Getting started - Setting table definition - Constraints and validators.php @@ -0,0 +1,35 @@ +Following data types and constraints are availible in doctrine +
-
+ unique
+
- Acts as database level unique constraint. Also validates that the specified column is unique.
+
- Nospace validator. This validator validates that specified column doesn't contain any space/newline characters.
+
- Notblank validator. This validator validates that specified column doesn't contain only space/newline characters. Useful in for example comment posting applications
+ where users are not allowed to post empty comments.
+
+ email + Email validator. Validates that specified column is a valid email address. + date + Date validator. + range:[args] + Range validator, eg range:1-32 + enum:[args] + Enum validator, eg enum:city1-city2-city3 + country +
- Country code validator validates that specified column has a valid country code.
+
- Regular expression validator validates that specified column matches a regular expression, eg regexp:[John]
+
- Ip validator validates that specified column is a valid internet protocol address.
+
- Usstate validator validates that specified column is a valid usstate.
+
-
+ string / s
+ The same as type 'string' in php
+ float / double / f
+ The same as type 'float' in php
+ integer / int / i + The same as type 'integer' in php
+ boolean / bool + The same as type 'boolean' in php
+ array / a +
- The same as type 'array' in php. Automatically serialized when saved into database and unserialized when retrieved from database.
- The same as type 'object' in php. Automatically serialized when saved into database and unserialized when retrieved from database.
- Unified 'enum' type. Automatically converts the string values into index numbers and vice versa. The possible values for the column
+ can be specified with Doctrine_Record::setEnumValues(columnName, array values).
+ +
Example 1. Column named 'content' with type 'string' and length 3000 results in database type 'TEXT' of which has database level length of 4000. +However when the record is validated it is only allowed to have 'content' -column with maximum length of 3000.
+ +
Example 2. Column with type 'integer' and length 1 results in 'TINYINT' on many databases. +
+ +In general Doctrine is smart enough to know which integer/string type to use depending on the specified length. + +
+ + diff --git a/manual/docs/Getting started - Setting table definition - Introduction.php b/manual/docs/Getting started - Setting table definition - Introduction.php new file mode 100644 index 000000000..1dbd9dd27 --- /dev/null +++ b/manual/docs/Getting started - Setting table definition - Introduction.php @@ -0,0 +1,7 @@ +Setting up a table definition in doctrine is done by using hasColumn method calls inside setTableDefinition method. +Doctrine_Record::hasColumn() takes 4 arguments:
+ +1. [column name]
+2. [column type]
+3. [column length]
+4. [column constraints and validators] diff --git a/manual/docs/Getting started - Starting new project.php b/manual/docs/Getting started - Starting new project.php new file mode 100644 index 000000000..1d257e3b9 --- /dev/null +++ b/manual/docs/Getting started - Starting new project.php @@ -0,0 +1,10 @@ +Doctrine_Record is the basic component of every doctrine-based project. +There should be atleast one Doctrine_Record for each of your database tables. +Doctrine_Record follows Active Record pattern. +
+Doctrine auto-creates database tables and always adds a primary key column named 'id' to tables. Only thing you need to for creating database tables +is defining a class which extends Doctrine_Record and setting a setTableDefinition method with hasColumn() method calls. +
+Consider we want to create a database table called 'user' with columns id(primary key), name, username, password and created. You only need couple of lines of code +to create a simple CRUD (Create, Retrieve, Update, Delete) application for this database table. + diff --git a/manual/docs/Mapping object relations - Composites and aggregates.php b/manual/docs/Mapping object relations - Composites and aggregates.php new file mode 100644 index 000000000..a512fb3e3 --- /dev/null +++ b/manual/docs/Mapping object relations - Composites and aggregates.php @@ -0,0 +1,8 @@ +Doctrine supports aggregates and composites. When binding composites you can use methods Doctrine_Table::ownsOne() and Doctrine_Table::ownsMany(). When binding +aggregates you can use methods Doctrine_Table::hasOne() and Doctrine_Table::hasMany(). +
+In Doctrine if you bind an Email to a User using ownsOne or ownsMany methods, everytime User record calls save or delete the associated +Email record is also saved/deleted. +
+Then again if you bind an Email to a User using hasOne or hasMany methods, everytime User record calls save or delete the associated +Email record is NOT saved/deleted. diff --git a/manual/docs/Mapping object relations - Dealing with relations - Creating related records.php b/manual/docs/Mapping object relations - Dealing with relations - Creating related records.php new file mode 100644 index 000000000..6955476a6 --- /dev/null +++ b/manual/docs/Mapping object relations - Dealing with relations - Creating related records.php @@ -0,0 +1 @@ +When accessing related records and if those records do not exists Doctrine automatically creates new records. diff --git a/manual/docs/Mapping object relations - Dealing with relations - Deleting related records.php b/manual/docs/Mapping object relations - Dealing with relations - Deleting related records.php new file mode 100644 index 000000000..37f75d0c2 --- /dev/null +++ b/manual/docs/Mapping object relations - Dealing with relations - Deleting related records.php @@ -0,0 +1,2 @@ +You can delete related records individually be calling delete() on each record. If you want to delete a whole record graph just call +delete on the owner record. diff --git a/manual/docs/Mapping object relations - Dealing with relations - Retrieving related records.php b/manual/docs/Mapping object relations - Dealing with relations - Retrieving related records.php new file mode 100644 index 000000000..903277284 --- /dev/null +++ b/manual/docs/Mapping object relations - Dealing with relations - Retrieving related records.php @@ -0,0 +1,2 @@ +You can retrieve related records by the very same Doctrine_Record methods you've already propably used for accessing record properties. +When accessing related record you just simply use the class names. diff --git a/manual/docs/Mapping object relations - Dealing with relations - Updating related records.php b/manual/docs/Mapping object relations - Dealing with relations - Updating related records.php new file mode 100644 index 000000000..7712c53c4 --- /dev/null +++ b/manual/docs/Mapping object relations - Dealing with relations - Updating related records.php @@ -0,0 +1,2 @@ +You can update the related records by calling save for each related object / collection individually or by calling +save on the object that owns the other objects. You can also call Doctrine_Session::flush which saves all pending objects. diff --git a/manual/docs/Mapping object relations - Foreign key associations - One-to-One.php b/manual/docs/Mapping object relations - Foreign key associations - One-to-One.php new file mode 100644 index 000000000..b279556ff --- /dev/null +++ b/manual/docs/Mapping object relations - Foreign key associations - One-to-One.php @@ -0,0 +1,7 @@ +Binding One-To-One foreign key associations is done with Doctrine_Record::ownsOne() and Doctrine_Record::hasOne() methods. +In the following example user owns one email and has one address. So the relationship between user and email is one-to-one composite. +The relationship between user and address is one-to-one aggregate. +
+The Email component here is mapped to User component's column email_id hence their relation is called LOCALKEY relation. +On the other hand the Address component is mapped to User by it's user_id column hence the relation between User and Address is called +FOREIGNKEY relation. diff --git a/manual/docs/Mapping object relations - Inheritance - Column aggregation.php b/manual/docs/Mapping object relations - Inheritance - Column aggregation.php new file mode 100644 index 000000000..8d399c14c --- /dev/null +++ b/manual/docs/Mapping object relations - Inheritance - Column aggregation.php @@ -0,0 +1,8 @@ +In the following example we have one database table called 'entity'. +Users and groups are both entities and they share the same database table. +
+The entity table has a column called 'type' which tells whether an entity is a group or a user. +Then we decide that users are type 1 and groups type 2. + +The only thing we have to do is to create 3 records (the same as before) and add +call the Doctrine_Table::setInheritanceMap() method inside the setUp() method. diff --git a/manual/docs/Mapping object relations - Inheritance - One table many classes.php b/manual/docs/Mapping object relations - Inheritance - One table many classes.php new file mode 100644 index 000000000..689114886 --- /dev/null +++ b/manual/docs/Mapping object relations - Inheritance - One table many classes.php @@ -0,0 +1,7 @@ +When it comes to handling inheritance Doctrine is very smart. +In the following example we have one database table called 'entity'. +Users and groups are both entities and they share the same database table. +The only thing we have to make is 3 records (Entity, Group and User). +
+Doctrine is smart enough to know that the inheritance type here is one-table-many-classes. + diff --git a/manual/docs/Mapping object relations - Inheritance - One table one class.php b/manual/docs/Mapping object relations - Inheritance - One table one class.php new file mode 100644 index 000000000..603eef0e8 --- /dev/null +++ b/manual/docs/Mapping object relations - Inheritance - One table one class.php @@ -0,0 +1,5 @@ +In the following example we have three database tables called 'entity', 'user' and 'group'. +Users and groups are both entities. +The only thing we have to do is write 3 classes (Entity, Group and User) and make iterative +setTableDefinition method calls. +
diff --git a/manual/docs/Mapping object relations - Join table associations - Many-to-Many.php b/manual/docs/Mapping object relations - Join table associations - Many-to-Many.php new file mode 100644 index 000000000..62be7e80f --- /dev/null +++ b/manual/docs/Mapping object relations - Join table associations - Many-to-Many.php @@ -0,0 +1,5 @@ +If you are coming from relational database background it may be familiar to you +how many-to-many associations are handled: an additional association table is needed. +
+In the following example we have Groups and Users of which relation is defined as +many-to-many. In this case we also need to define an additional class called Groupuser. diff --git a/manual/docs/Mapping object relations - Join table associations - Self-referencing.php b/manual/docs/Mapping object relations - Join table associations - Self-referencing.php new file mode 100644 index 000000000..7e41044c4 --- /dev/null +++ b/manual/docs/Mapping object relations - Join table associations - Self-referencing.php @@ -0,0 +1 @@ +Self-referencing with join tables is done as follows: diff --git a/manual/docs/Mapping object relations - One-to-Many and One-to-One relationships.php b/manual/docs/Mapping object relations - One-to-Many and One-to-One relationships.php new file mode 100644 index 000000000..d3f5a12fa --- /dev/null +++ b/manual/docs/Mapping object relations - One-to-Many and One-to-One relationships.php @@ -0,0 +1 @@ + diff --git a/manual/docs/Mapping object relations - Relation aliases.php b/manual/docs/Mapping object relations - Relation aliases.php new file mode 100644 index 000000000..6ba9c1515 --- /dev/null +++ b/manual/docs/Mapping object relations - Relation aliases.php @@ -0,0 +1 @@ +Doctrine supports relation aliases through 'as' keyword. diff --git a/manual/docs/Real world examples - User management system.php b/manual/docs/Real world examples - User management system.php new file mode 100644 index 000000000..3ba1e772f --- /dev/null +++ b/manual/docs/Real world examples - User management system.php @@ -0,0 +1,21 @@ +In the following example we make a user management system where +
+1. Each user and group are entities +
+2. User is an entity of type 0 +
+3. Group is an entity of type 1 +
+4. Each entity (user/group) has 0-1 email +
+5. Each entity has 0-* phonenumbers +
+6. If an entity is saved all its emails and phonenumbers are also saved +
+7. If an entity is deleted all its emails and phonenumbers are also deleted +
+8. When an entity is created and saved a current timestamp will be assigned to 'created' field +
+9. When an entity is updated a current timestamp will be assigned to 'updated' field +
+10. Entities will always be fetched in batches diff --git a/manual/docs/Runtime classes - Doctrine_Association.php b/manual/docs/Runtime classes - Doctrine_Association.php new file mode 100644 index 000000000..d29d1e7ff --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Association.php @@ -0,0 +1 @@ +Doctrine_Association represents a many-to-many association between database tables. diff --git a/manual/docs/Runtime classes - Doctrine_Collection.php b/manual/docs/Runtime classes - Doctrine_Collection.php new file mode 100644 index 000000000..775cb0c86 --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Collection.php @@ -0,0 +1 @@ +Doctrine_Collection is a collection of Data Access Objects. Doctrine_Collection represents a record set. diff --git a/manual/docs/Runtime classes - Doctrine_Collection_Batch.php b/manual/docs/Runtime classes - Doctrine_Collection_Batch.php new file mode 100644 index 000000000..77b2e4f41 --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Collection_Batch.php @@ -0,0 +1 @@ +Doctrine_Collection_Batch is a Doctrine_Collection with batch fetching strategy. diff --git a/manual/docs/Runtime classes - Doctrine_Collection_Immediate.php b/manual/docs/Runtime classes - Doctrine_Collection_Immediate.php new file mode 100644 index 000000000..dde19e48b --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Collection_Immediate.php @@ -0,0 +1 @@ +Doctrine_Collection_Immediate is a Doctrine_Collection with immediate fetching strategy. diff --git a/manual/docs/Runtime classes - Doctrine_Collection_Lazy.php b/manual/docs/Runtime classes - Doctrine_Collection_Lazy.php new file mode 100644 index 000000000..d36ad04dc --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Collection_Lazy.php @@ -0,0 +1 @@ +Doctrine_Collection_Lazy is a Doctrine_Collection with lazy fetching strategy. diff --git a/manual/docs/Runtime classes - Doctrine_ForeignKey.php b/manual/docs/Runtime classes - Doctrine_ForeignKey.php new file mode 100644 index 000000000..a039df04d --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_ForeignKey.php @@ -0,0 +1 @@ +Doctrine_ForeignKey represents a one-to-many association or one-to-one association between two database tables. diff --git a/manual/docs/Runtime classes - Doctrine_Manager.php b/manual/docs/Runtime classes - Doctrine_Manager.php new file mode 100644 index 000000000..9af9f4b0b --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Manager.php @@ -0,0 +1,2 @@ +Doctrine_Manager is the base component of Doctrine ORM framework. Doctrine_Manager is a colletion of Doctrine_Sessions. All the new sessions are being +opened by Doctrine_Manager::openSession(). diff --git a/manual/docs/Runtime classes - Doctrine_Record.php b/manual/docs/Runtime classes - Doctrine_Record.php new file mode 100644 index 000000000..488d59ab9 --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Record.php @@ -0,0 +1,2 @@ +Doctrine_Record is a wrapper for database row. + diff --git a/manual/docs/Runtime classes - Doctrine_Session.php b/manual/docs/Runtime classes - Doctrine_Session.php new file mode 100644 index 000000000..2d80442da --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Session.php @@ -0,0 +1,3 @@ +Doctrine_Session is a wrapper for database connection. It creates Doctrine_Tables and keeps track of all the created tables. +Doctrine_Session provides things that are missing from PDO like sequence support and limit/offset emulation. + diff --git a/manual/docs/Runtime classes - Doctrine_Table.php b/manual/docs/Runtime classes - Doctrine_Table.php new file mode 100644 index 000000000..748406d97 --- /dev/null +++ b/manual/docs/Runtime classes - Doctrine_Table.php @@ -0,0 +1,2 @@ +Doctrine_Table creates records and holds info of all foreign keys and associations. Doctrine_Table +represents a database table. diff --git a/manual/docs/Technology - Design patterns used.php b/manual/docs/Technology - Design patterns used.php new file mode 100644 index 000000000..243a57235 --- /dev/null +++ b/manual/docs/Technology - Design patterns used.php @@ -0,0 +1,46 @@ +GoF [Gang Of Four] design patterns used: +
+
+
+
+
+
+
+
+
+
+Enterprise application design patterns used: +
+
+
+
+
+
+
+
+
+
+
+For collection elements +
+
+Doctrine knows how to fetch collections efficiently using a subselect. +
+
+The session never issues an INSERT or UPDATE until it is actually needed. So if an exception occurs and you need to abort the transaction, some statements will never actually be issued. Furthermore, this keeps lock times in the database as short as possible (from the late UPDATE to the transaction end). +
+
+Doctrine knows how to fetch complex object graphs using joins and subselects +
+
+Doctrine has multiple collection fetching strategies for performance tuning. +
+
+Fetching strategies can be mixed and for example users can be fetched in a batch collection while +users' phonenumbers are loaded in offset collection using only one query. +
+
+Doctrine knows things like bulk-insert on mysql +
+
+Doctrine knows how to gather all the primary keys of the pending objects in delete list and performs only one sql delete statement per table. +
+
+Doctrine always knows which columns have been changed. +
+
+Doctrine knows if the the state of the record has changed. +
+
+PDO is by far the fastest availible database abstraction layer for php. +
+ diff --git a/manual/documentation.php b/manual/documentation.php new file mode 100644 index 000000000..284b1c573 --- /dev/null +++ b/manual/documentation.php @@ -0,0 +1,532 @@ +".$t."
\n"; + $c = ""; + + if(file_exists("docs/$e.php")) { + rename("docs/$e.php","docs/$title - $t.php"); + } + if(file_exists("docs/$t.php")) { + rename("docs/$t.php","docs/$title - $t.php"); + } + if(file_exists("docs/$title - $t.php")) { + $c = file_get_contents("docs/$title - $t.php"); + if(substr($c,0,5) == "
"; + } + $c = ""; + if(file_exists("codes/$e.php")) { + rename("codes/$e.php","codes/$title - $t.php"); + } + if(file_exists("codes/$t.php")) { + rename("codes/$t.php","codes/$title - $t.php"); + } + if(file_exists("codes/$title - $t.php")) { + print "
| "; + $c = file_get_contents("codes/$title - $t.php"); + $h->loadString($c); + print $h->toHtml(); + print " |
"; +} + +function render_block($name) { + $h = new PHP_Highlight; + if(file_exists("docs/$name.php")) { + $c = file_get_contents("docs/$name.php"); + if(substr($c,0,5) == "
"; + } + } + if(file_exists("codes/$name.php")) { + print "
| "; + $c = file_get_contents("codes/$name.php"); + $h->loadString($c); + print $h->toHtml(); + print " |
| + | + |
+
. + * + * @access public + * @param bool $return Return rather than print the results + * @param bool $linenum Display line numbers + * @param string $format Specify format of line numbers displayed + * @param bool $funcref Reference functions to the PHP manual + * @return string A HTML block of code + */ + function toHtml($return = false, $linenum = false, $format = null, $funcref = true) + { + // Ensure source has been loaded + if ($this->_source == false) { + return false; + } + + // Line numbering + if ($linenum === true && $format === null) { + $format = '%02d '; + } + + // Format code + $source = $this->toArray($funcref); + $out = " \n";
+ foreach ($source as $i => $line) {
+ $out .= ' ';
+
+ if ($linenum === true) {
+ $out .= sprintf($format, $i);
+ }
+
+ $out .= empty($line) ? ' ' : $line;
+ $out .= "\n";
+
+ if ($return === true) {
+ return $out;
+ } else {
+ echo $out;
+ }
+ }
+
+
+ /**
+ * Convert the source to formatted HTML blocks.
+ * Each line ends with . + * + * This method ensures only PHP is between blocks.
+ *
+ * @access public
+ * @param bool $return Return rather than print the results
+ * @param bool $linenum Display line numbers
+ * @param string $format Specify format of line numbers displayed
+ * @param bool $reset Reset the line numbering each block
+ * @param bool $funcref Reference functions to the PHP manual
+ * @return string A HTML block of code
+ */
+ function toHtmlBlocks($return = false, $linenum = false, $format = null, $reset = true, $funcref = true)
+ {
+ // Ensure source has been loaded
+ if ($this->_source == false) {
+ return false;
+ }
+
+ // Default line numbering
+ if ($linenum === true && $format === null) {
+ $format = '%03d ';
+ }
+
+ // Init
+ $source = $this->toArray($funcref, true);
+ $out = '';
+ $wasplain = true;
+ $k = 0;
+
+ // Loop through each line and decide which block to use
+ foreach ($source as $i => $line) {
+ // Empty line
+ if (empty($line)) {
+ if ($wasplain === true) {
+ $out .= ' ';
+ } else {
+ if (in_array($i+1, $this->_plaintextkeys)) {
+ $out .= "\n";
+
+ // Reset line numbers
+ if ($reset === true) {
+ $k = 0;
+ }
+ } else {
+ $out .= ' ';
+ // Add line number
+ if ($linenum === true) {
+ $out .= sprintf($format, ++$k);
+ }
+ }
+ }
+
+ // Plain text
+ } elseif (in_array($i, $this->_plaintextkeys)) {
+ if ($wasplain === false) {
+ $out .= "\n";
+
+ // Reset line numbers
+ if ($reset === true) {
+ $k = 0;
+ }
+ }
+
+ $wasplain = true;
+ $out .= str_replace(' ', ' ', $line);
+
+ // Code
+ } else {
+ if ($wasplain === true) {
+ $out .= "\n";
+ }
+ $wasplain = false;
+
+ $out .= ' ';
+ // Add line number
+ if ($linenum === true) {
+ $out .= sprintf($format, ++$k);
+ }
+ $out .= $line;
+ }
+
+ $out .= "\n";
+ }
+
+ // Output method
+ if ($return === true) {
+ return $out;
+ } else {
+ echo $out;
+ }
+ }
+
+
+ /**
+ * Assign a color based on the name of a token
+ *
+ * @access private
+ * @param int $token The token
+ * @return string The color of the token
+ */
+ function _token2color($token)
+ {
+
+ switch ($token):
+ case T_CONSTANT_ENCAPSED_STRING:
+ return $this->highlight['string'];
+ break;
+
+ case T_INLINE_HTML:
+ return $this->highlight['html'];
+ break;
+
+ case T_COMMENT:
+ case T_DOC_COMMENT:
+ case T_ML_COMMENT:
+ return $this->highlight['comment'];
+ break;
+
+ case T_ABSTRACT:
+ case T_ARRAY:
+ case T_ARRAY_CAST:
+ case T_AS:
+ case T_BOOLEAN_AND:
+ case T_BOOLEAN_OR:
+ case T_BOOL_CAST:
+ case T_BREAK:
+ case T_CASE:
+ case T_CATCH:
+ case T_CLASS:
+ case T_CLONE:
+ case T_CONCAT_EQUAL:
+ case T_CONTINUE:
+ case T_DEFAULT:
+ case T_DOUBLE_ARROW:
+ case T_DOUBLE_CAST:
+ case T_ECHO:
+ case T_ELSE:
+ case T_ELSEIF:
+ case T_EMPTY:
+ case T_ENDDECLARE:
+ case T_ENDFOR:
+ case T_ENDFOREACH:
+ case T_ENDIF:
+ case T_ENDSWITCH:
+ case T_ENDWHILE:
+ case T_END_HEREDOC:
+ case T_EXIT:
+ case T_EXTENDS:
+ case T_FINAL:
+ case T_FOREACH:
+ case T_FUNCTION:
+ case T_GLOBAL:
+ case T_IF:
+ case T_INC:
+ case T_INCLUDE:
+ case T_INCLUDE_ONCE:
+ case T_INSTANCEOF:
+ case T_INT_CAST:
+ case T_ISSET:
+ case T_IS_EQUAL:
+ case T_IS_IDENTICAL:
+ case T_IS_NOT_IDENTICAL:
+ case T_IS_SMALLER_OR_EQUAL:
+ case T_NEW:
+ case T_OBJECT_CAST:
+ case T_OBJECT_OPERATOR:
+ case T_PAAMAYIM_NEKUDOTAYIM:
+ case T_PRIVATE:
+ case T_PROTECTED:
+ case T_PUBLIC:
+ case T_REQUIRE:
+ case T_REQUIRE_ONCE:
+ case T_RETURN:
+ case T_SL:
+ case T_SL_EQUAL:
+ case T_SR:
+ case T_SR_EQUAL:
+ case T_START_HEREDOC:
+ case T_STATIC:
+ case T_STRING_CAST:
+ case T_THROW:
+ case T_TRY:
+ case T_UNSET_CAST:
+ case T_VAR:
+ case T_WHILE:
+ return $this->highlight['keyword'];
+ break;
+
+ case T_CLOSE_TAG:
+ case T_OPEN_TAG:
+ case T_OPEN_TAG_WITH_ECHO:
+ default:
+ return $this->highlight['default'];
+
+ endswitch;
+ }
+
+}
+
+?>
diff --git a/manual/images/docflash.jpg b/manual/images/docflash.jpg
new file mode 100644
index 000000000..0e0d6a71b
Binary files /dev/null and b/manual/images/docflash.jpg differ
diff --git a/manual/images/docflashbg.jpg b/manual/images/docflashbg.jpg
new file mode 100644
index 000000000..3821958db
Binary files /dev/null and b/manual/images/docflashbg.jpg differ
diff --git a/manual/images/docnew.gif b/manual/images/docnew.gif
new file mode 100644
index 000000000..60a9c7080
Binary files /dev/null and b/manual/images/docnew.gif differ
diff --git a/manual/images/gradient1.jpg b/manual/images/gradient1.jpg
new file mode 100644
index 000000000..254ead776
Binary files /dev/null and b/manual/images/gradient1.jpg differ
diff --git a/manual/images/gradient2.jpg b/manual/images/gradient2.jpg
new file mode 100644
index 000000000..4c94fd978
Binary files /dev/null and b/manual/images/gradient2.jpg differ
diff --git a/manual/images/gradient3.jpg b/manual/images/gradient3.jpg
new file mode 100644
index 000000000..cc86606f1
Binary files /dev/null and b/manual/images/gradient3.jpg differ
diff --git a/manual/images/logo.jpg b/manual/images/logo.jpg
new file mode 100644
index 000000000..8f3660ece
Binary files /dev/null and b/manual/images/logo.jpg differ
diff --git a/manual/images/tausta2.jpg b/manual/images/tausta2.jpg
new file mode 100644
index 000000000..b79d65692
Binary files /dev/null and b/manual/images/tausta2.jpg differ
diff --git a/manual/styles/basic.css b/manual/styles/basic.css
new file mode 100644
index 000000000..e2b640279
--- /dev/null
+++ b/manual/styles/basic.css
@@ -0,0 +1,49 @@
+body {
+margin: 10,0,0,0;
+font-family: Verdana, Arial, Helvetica;
+text-decoration: none;
+}
+
+hr {
+color: A50A3D;
+}
+hr.small {
+color: A50A3D;
+width: 100%;
+align: left;
+height: 1 px;
+}
+td.small {
+font-family: Verdana, Arial, Helvetica;
+font-size: 12 px;
+}
+dd {
+ line-height: 1.5em;
+}
+ul {
+ line-height: 1.5em;
+}
+td {
+font-size: 12 px;
+font-family: Verdana, Arial, Helvetica;
+}
+joo {
+color: A50A3D;
+}
+table.dashed {
+border-style: solid;
+border-color: 116699;
+border-width: 1 px;
+}
+b.title {
+color: #A50A3D;
+}
+u.title {
+color: #367FAC;
+}
+a.big {
+font-size: 13 px;
+}
+a {
+color: #367FAC;
+}
diff --git a/manual/styles/steel.css b/manual/styles/steel.css
new file mode 100644
index 000000000..87e9174f1
--- /dev/null
+++ b/manual/styles/steel.css
@@ -0,0 +1,45 @@
+body {
+margin: 10,0,0,0;
+font-family: Verdana, Arial, Helvetica;
+text-decoration: none;
+background: #393939;
+color: #dfdfdf;
+}
+hr {
+color: a3cb14;
+}
+hr.small {
+color: a3cb14;
+width: 100%;
+align: left;
+height: 1 px;
+}
+td.small {
+font-family: Verdana, Arial, Helvetica;
+font-size: 12 px;
+}
+td {
+font-size: 12 px;
+font-family: Verdana, Arial, Helvetica;
+background: #393939;
+}
+joo {
+color: A50A3D;
+}
+table.dashed {
+border-style: solid;
+border-color: 116699;
+border-width: 1 px;
+}
+b.title {
+color: #0090d9;
+}
+u.title {
+color: #367FAC;
+}
+a.big {
+font-size: 13 px;
+}
+a {
+color: #a3cb14;
+}
diff --git a/manual/top.php b/manual/top.php
new file mode 100644
index 000000000..7de1cb637
--- /dev/null
+++ b/manual/top.php
@@ -0,0 +1,22 @@
+
+
+
+
| ||||||||||||||||||||
Doctrine - PHP Data Persistence and ORM Tool
+ 
+