Using the atkMetaNode - Revision history

Wayneh: /* Show me the way */

2018-06-10T23:28:15Z

Show me the way

← Older revision		Revision as of 23:28, 10 June 2018
Line 125:		Line 125:

	There are other variables you can use to specify a different meta policy, a different sequence name etc. For now, just look at the sources of the atkMetaNode class.		There are other variables you can use to specify a different meta policy, a different sequence name etc. For now, just look at the sources of the atkMetaNode class.

			Other variabkles include $flags (for Node flags), $descriptor for Node descriptor, $filter for Node filter, $alias for Node security alias, $map for Node security map

	== Caching ==		== Caching ==

bahtiar: /* Caching */

2008-03-22T11:37:18Z

Caching

← Older revision		Revision as of 11:37, 22 March 2008
Line 129:		Line 129:
	The meta node uses the database metadata to build the node. To prevent the node from doing this every single request we've added a caching mechanism. This caching mechanism compiles the meta policy to PHP code which is applied to the node in subsequent requests. This improves the performance of the meta node and makes it also easier to debug your code. You can find the compiled code inside the meta subdirectory of the ATK temp directory. This directory has the following structure: meta/<module>/<node>.php. So this means that the compiled code for the node called "country" inside the module "example" can be found in <ATK temp>/meta/example/country.php.		The meta node uses the database metadata to build the node. To prevent the node from doing this every single request we've added a caching mechanism. This caching mechanism compiles the meta policy to PHP code which is applied to the node in subsequent requests. This improves the performance of the meta node and makes it also easier to debug your code. You can find the compiled code inside the meta subdirectory of the ATK temp directory. This directory has the following structure: meta/<module>/<node>.php. So this means that the compiled code for the node called "country" inside the module "example" can be found in <ATK temp>/meta/example/country.php.

	During the development it might be better to turn of the caching mechanism because you might be still changing the structure of your database. To do so you can set the special $config_meta_caching configuration option to FALSE.		During the development it might be better to turn off the caching mechanism because you might be still changing the structure of your database. To do so you can set the special $config_meta_caching configuration option to FALSE.

	== Conclusion ==		== Conclusion ==
	Well that's it for now. This howto should have given at least a small impression of the possibilities the atkMetaNode has to offer. Future versions will describe more (hidden) features of the atkMetaNode.		Well that's it for now. This howto should have given at least a small impression of the possibilities the atkMetaNode has to offer. Future versions will describe more (hidden) features of the atkMetaNode.

Peter at 18:40, 18 March 2008

2008-03-18T18:40:17Z

← Older revision		Revision as of 18:40, 18 March 2008
Line 52:		Line 52:
	class Contact extends atkMetaNode		class Contact extends atkMetaNode
	{		{
	function meta(&$policy)		public static function meta($policy)
	{		{
	$policy->hasOne("country");		$policy->hasOne("country");
Line 64:		Line 64:
	class Contact extends atkMetaNode		class Contact extends atkMetaNode
	{		{
	function meta(&$policy)		public static function meta($policy)
	{		{
	$policy->hasOne("country", "[name] ([iso_code])");		$policy->hasOne("country", "[name] ([iso_code])");
Line 71:		Line 71:
	</syntaxhighlight>		</syntaxhighlight>

	That looks more like it! But what did we really do here? Well first of all we ~~have overridden~~ the special meta method. This method is ~~always~~ called from within the atkMetaNode's constructor and is supplied with the so called meta policy. The meta policy performs the real magic for the atkMetaNode; mapping table columns to attributes, adding relations to the node with a minimal amount of hinting etc. The best thing is, if you don't like the current detection scheme of the default meta policy, you can simply subclass it and create your own policy. Inside the meta method you can call some methods on the policy used for the node to give some hints. In the example above we hint the policy that we have a relation with the country node. The policy then determines if this is a one-to-one or many-to-one relation, what columns need to be used etc.		That looks more like it! But what did we really do here? Well first of all we've implemented the special meta method. This method is called from within the atkMetaNode's constructor and is supplied with the so called meta policy. The meta policy performs the real magic for the atkMetaNode; mapping table columns to attributes, adding relations to the node with a minimal amount of hinting etc. The best thing is, if you don't like the current detection scheme of the default meta policy, you can simply subclass it and create your own policy. Inside the meta method you can call some methods on the policy used for the node to give some hints. In the example above we hint the policy that we have a relation with the country node. The policy then determines if this is a one-to-one or many-to-one relation, what columns need to be used etc. Make sure you always declare your meta method as "public static", this way you ensure that you don't (by accident) use $this inside your meta method and this also assures that the automatic caching mechanism kicks in (more on this later).

	Ofcourse there are more hinting methods you can use. Let's give an example:		Ofcourse there are more hinting methods you can use. Let's give an example:
Line 78:		Line 78:
	class Contact extends atkMetaNode		class Contact extends atkMetaNode
	{		{
	function meta(&$policy)		public static function meta($policy)
	{		{
	$policy->hasOne("country", "[name] ([iso_code])");		$policy->hasOne("country", "[name] ([iso_code])");
Line 100:		Line 100:
	class Country extends atkMetaNode		class Country extends atkMetaNode
	{		{
	function meta(&$policy)		public static function meta($policy)
	{		{
	$policy->hasMany("contacts", "[email]");		$policy->hasMany("contacts", "[email]");
Line 115:		Line 115:
	class Country extends atkMetaNode		class Country extends atkMetaNode
	{		{
	~~var~~ $table = "lesson6_country";		protected $table = "lesson6_country";

	function meta(&$policy)		public static function meta($policy)
	{		{
	$policy->hasMany("contacts", "[email]");		$policy->hasMany("contacts", "[email]");
Line 125:		Line 125:

	There are other variables you can use to specify a different meta policy, a different sequence name etc. For now, just look at the sources of the atkMetaNode class.		There are other variables you can use to specify a different meta policy, a different sequence name etc. For now, just look at the sources of the atkMetaNode class.

			== Caching ==
			The meta node uses the database metadata to build the node. To prevent the node from doing this every single request we've added a caching mechanism. This caching mechanism compiles the meta policy to PHP code which is applied to the node in subsequent requests. This improves the performance of the meta node and makes it also easier to debug your code. You can find the compiled code inside the meta subdirectory of the ATK temp directory. This directory has the following structure: meta/<module>/<node>.php. So this means that the compiled code for the node called "country" inside the module "example" can be found in <ATK temp>/meta/example/country.php.

			During the development it might be better to turn of the caching mechanism because you might be still changing the structure of your database. To do so you can set the special $config_meta_caching configuration option to FALSE.

	== Conclusion ==		== Conclusion ==

	Well that's it for now. This howto should have given at least a small impression of the possibilities the atkMetaNode has to offer. Future versions will describe more (hidden) features of the atkMetaNode.		Well that's it for now. This howto should have given at least a small impression of the possibilities the atkMetaNode has to offer. Future versions will describe more (hidden) features of the atkMetaNode.

Mcleod: /* Show me the money^H^H^H^H^Hway */

2007-09-29T13:55:49Z

Show me the money^H^H^H^H^Hway

← Older revision		Revision as of 13:55, 29 September 2007
Line 9:		Line 9:
	The atkMetaNode uses meta data readily available in the database to determine of which attributes a node should consist of, which type these attributes should have, what their flags should be etc. Most of the time the atkMetaNode is quite able to determine things on it's own, but sometimes you must give some hints to make things work the way you want. After the node construction based on the database meta data is done you can just handle the node as any other ordinary node. This means you can even add your own attributes to the node, like you would normally do, but most of the times this won't be needed.		The atkMetaNode uses meta data readily available in the database to determine of which attributes a node should consist of, which type these attributes should have, what their flags should be etc. Most of the time the atkMetaNode is quite able to determine things on it's own, but sometimes you must give some hints to make things work the way you want. After the node construction based on the database meta data is done you can just handle the node as any other ordinary node. This means you can even add your own attributes to the node, like you would normally do, but most of the times this won't be needed.

	== Show me the ~~money^H^H^H^H^Hway~~ ==		== Show me the way==

	So you would like to know how to use the atkMetaNode in practice? Well here it comes. If our database would contain a table called country which consists of the following columns:		So you would like to know how to use the atkMetaNode in practice? Well here it comes. If our database would contain a table called country which consists of the following columns:

Peter at 07:53, 18 April 2007

2007-04-18T07:53:57Z

← Older revision		Revision as of 07:53, 18 April 2007
Line 1:		Line 1:
	{{Howto\|~~Advanced~~\|[[Peter C. Verhage]] <peter@achievo.org>}}		{{Howto\|Intermediate\|[[Peter C. Verhage]] <peter@achievo.org>}}

	== Preface ==		== Preface ==

bahtiar at 09:37, 14 January 2007

2007-01-14T09:37:40Z

← Older revision		Revision as of 09:37, 14 January 2007
Line 44:		Line 44:
	Initially we will also create a meta node for this table in just a single line of code, just like before:		Initially we will also create a meta node for this table in just a single line of code, just like before:

	class Contact extends atkMetaNode {}		<syntaxhighlight lang="php">class Contact extends atkMetaNode {}</syntaxhighlight>


	But if we do this, you will see you just get a simple country_id field, in which a user can enter the numerical identifier of a certain country. Not that user friendly, is it? First of all a user needs to know what country identifiers are valid and secondly what identifier belongs to which country. We can do better than that, let's use a many-to-one relation. Change the contact node code to the following:		But if we do this, you will see you just get a simple country_id field, in which a user can enter the numerical identifier of a certain country. Not that user friendly, is it? First of all a user needs to know what country identifiers are valid and secondly what identifier belongs to which country. We can do better than that, let's use a many-to-one relation. Change the contact node code to the following:

			<syntaxhighlight lang="php">
	class Contact extends atkMetaNode		class Contact extends atkMetaNode
	{		{
Line 56:		Line 57:
	}		}
	}		}
			</syntaxhighlight>

	Now the user will be presented with a list of countries, but unfortunately this list still consists of only the numerical identifier for the countries. There are two ways to solve this problem. First of all you could create a method called descriptor_def in the country node which returns a descriptor template like [name]. But what if you don't have access to this node (because another user has written it), or what if you want to display both the iso code and name instead of just the name (which is currently defined in the descriptor_def method)? Simply add a second parameter to the call to the hasOne method in which we define the descriptor template:		Now the user will be presented with a list of countries, but unfortunately this list still consists of only the numerical identifier for the countries. There are two ways to solve this problem. First of all you could create a method called descriptor_def in the country node which returns a descriptor template like [name]. But what if you don't have access to this node (because another user has written it), or what if you want to display both the iso code and name instead of just the name (which is currently defined in the descriptor_def method)? Simply add a second parameter to the call to the hasOne method in which we define the descriptor template:

			<syntaxhighlight lang="php">
	class Contact extends atkMetaNode		class Contact extends atkMetaNode
	{		{
Line 67:		Line 69:
	}		}
	}		}
			</syntaxhighlight>

	That looks more like it! But what did we really do here? Well first of all we have overridden the special meta method. This method is always called from within the atkMetaNode's constructor and is supplied with the so called meta policy. The meta policy performs the real magic for the atkMetaNode; mapping table columns to attributes, adding relations to the node with a minimal amount of hinting etc. The best thing is, if you don't like the current detection scheme of the default meta policy, you can simply subclass it and create your own policy. Inside the meta method you can call some methods on the policy used for the node to give some hints. In the example above we hint the policy that we have a relation with the country node. The policy then determines if this is a one-to-one or many-to-one relation, what columns need to be used etc.		That looks more like it! But what did we really do here? Well first of all we have overridden the special meta method. This method is always called from within the atkMetaNode's constructor and is supplied with the so called meta policy. The meta policy performs the real magic for the atkMetaNode; mapping table columns to attributes, adding relations to the node with a minimal amount of hinting etc. The best thing is, if you don't like the current detection scheme of the default meta policy, you can simply subclass it and create your own policy. Inside the meta method you can call some methods on the policy used for the node to give some hints. In the example above we hint the policy that we have a relation with the country node. The policy then determines if this is a one-to-one or many-to-one relation, what columns need to be used etc.
Line 73:		Line 75:
	Ofcourse there are more hinting methods you can use. Let's give an example:		Ofcourse there are more hinting methods you can use. Let's give an example:

			<syntaxhighlight lang="php">
	class Contact extends atkMetaNode		class Contact extends atkMetaNode
	{		{
Line 83:		Line 86:
	}		}
	}		}
			</syntaxhighlight>


Line 93:		Line 97:
	We've already seen the hasOne hint method which can be used for both many-to-one and one-to-one relations. But there also exists a hasMany method if you want to add a one-to-many relation, this method works the same as the hasOne method. A nice feature of the relation hinting methods is that they try to find the destination node using different names based on the supplied accessor name. If we would like to show the contacts in a certain country we could supply the meta policy for the country node with the following hint:		We've already seen the hasOne hint method which can be used for both many-to-one and one-to-one relations. But there also exists a hasMany method if you want to add a one-to-many relation, this method works the same as the hasOne method. A nice feature of the relation hinting methods is that they try to find the destination node using different names based on the supplied accessor name. If we would like to show the contacts in a certain country we could supply the meta policy for the country node with the following hint:

			<syntaxhighlight lang="php">
	class Country extends atkMetaNode		class Country extends atkMetaNode
	{		{
Line 100:		Line 105:
	}		}
	}		}
			</syntaxhighlight>


Line 106:		Line 112:
	Sometimes you may want (or need) to use a class name for your node that differs from the table name. If this happens to be the case you could override the constructor of your node and specify the table name as one of the parameters to the super constructor (see the ATK PHPdocs). But fortunately there is a nicer way to do this, just add an instance variable named $table to your class and give it as value the table name you want to use:		Sometimes you may want (or need) to use a class name for your node that differs from the table name. If this happens to be the case you could override the constructor of your node and specify the table name as one of the parameters to the super constructor (see the ATK PHPdocs). But fortunately there is a nicer way to do this, just add an instance variable named $table to your class and give it as value the table name you want to use:

			<syntaxhighlight lang="php">
	class Country extends atkMetaNode		class Country extends atkMetaNode
	{		{
Line 115:		Line 122:
	}		}
	}		}
			</syntaxhighlight>

	There are other variables you can use to specify a different meta policy, a different sequence name etc. For now, just look at the sources of the atkMetaNode class.		There are other variables you can use to specify a different meta policy, a different sequence name etc. For now, just look at the sources of the atkMetaNode class.

Patrick: /* Show me the money^H^H^H^H^Hway */

2007-01-05T13:29:17Z

Show me the money^H^H^H^H^Hway

← Older revision		Revision as of 13:29, 5 January 2007
Line 69:		Line 69:


	That looks more like it! But what did we really do here? Well first of all we have ~~overriden~~ the special meta method. This method is always called from within the atkMetaNode's constructor and is supplied with the so called meta policy. The meta policy performs the real magic for the atkMetaNode; mapping table columns to attributes, adding relations to the node with a minimal amount of hinting etc. The best thing is, if you don't like the current detection scheme of the default meta policy, you can simply subclass it and create your own policy. Inside the meta method you can call some methods on the policy used for the node to give some hints. In the example above we hint the policy that we have a relation with the country node. The policy then determines if this is a one-to-one or many-to-one relation, what columns need to be used etc.		That looks more like it! But what did we really do here? Well first of all we have overridden the special meta method. This method is always called from within the atkMetaNode's constructor and is supplied with the so called meta policy. The meta policy performs the real magic for the atkMetaNode; mapping table columns to attributes, adding relations to the node with a minimal amount of hinting etc. The best thing is, if you don't like the current detection scheme of the default meta policy, you can simply subclass it and create your own policy. Inside the meta method you can call some methods on the policy used for the node to give some hints. In the example above we hint the policy that we have a relation with the country node. The policy then determines if this is a one-to-one or many-to-one relation, what columns need to be used etc.

	Ofcourse there are more hinting methods you can use. Let's give an example:		Ofcourse there are more hinting methods you can use. Let's give an example:
Line 85:		Line 85:


	The setIncludes method can be used ~~for~~ specify the only columns this node should consist of. In the example above we told the policy to only include the contact_id, email, firstname, lastname and city columns. We can also specify the opposite by calling the setExcludes method, as you might have guessed this method can be used to specify a list of columns that should not be used by the node. The setIncludes method also determines (by default) the order of the attributes. Normally the meta node uses the order of the table columns. But you can use the hint method setOrder to specify another order. The setIncludes method calls the setOrder method by default, unless you specify FALSE as the last parameter.		The setIncludes method can be used to specify the only columns this node should consist of. In the example above we told the policy to only include the contact_id, email, firstname, lastname and city columns. We can also specify the opposite by calling the setExcludes method, as you might have guessed this method can be used to specify a list of columns that should not be used by the node. The setIncludes method also determines (by default) the order of the attributes. Normally the meta node uses the order of the table columns. But you can use the hint method setOrder to specify another order. The setIncludes method calls the setOrder method by default, unless you specify FALSE as the last parameter.

	The addFlags (and also the addFlag) method can be used to specify additional flags for attributes. The example above shows that you can call this method specifying one or more column/attribute names and a flag (or a combination of flags using the bitwise AND operator). Next to the addFlags method there is also a method to remove flags (removeFlags) and a method to set the flags (setFlags) instead of adding the flags.		The addFlags (and also the addFlag) method can be used to specify additional flags for attributes. The example above shows that you can call this method specifying one or more column/attribute names and a flag (or a combination of flags using the bitwise AND operator). Next to the addFlags method there is also a method to remove flags (removeFlags) and a method to set the flags (setFlags) instead of adding the flags.

Patrick: /* Show me the money^H^H^H^H^Hway */ small grammar fix

2007-01-05T13:19:34Z

Show me the money^H^H^H^H^Hway: small grammar fix

← Older revision		Revision as of 13:19, 5 January 2007
Line 19:		Line 19:
	name varchar(100) not null		name varchar(100) not null

	~~Creating~~ a (meta) node for the country table is simply a matter of creating a file called class.country.inc in your ATK module which consists of the following code:		then creating a (meta) node for the country table is simply a matter of creating a file called class.country.inc in your ATK module which consists of the following code:

	class Country extends atkMetaNode {}		class Country extends atkMetaNode {}

bahtiar: antispam

2006-10-24T23:28:08Z

antispam

Show changes

Punchcard at 14:14, 23 October 2006

2006-10-23T14:14:25Z

Show changes