Below is the code how I created those links using Custom SQL. But I have to tell you that the former methods looks organized, this is just a work around to a situation. You might know what I am trying to say!

$resource 	= Mage :: getSingleton( 'core/resource' );
$read= $resource -> getConnection( 'core_read' );
$write= $resource->getConnection('core_write');
$linkTable=$resource->getTableName('catalog/product_link');

// Creating Upsell Product link

$write->query("INSERT into $linkTable SET
							product_id='".$productId."',
							linked_product_id='".$linkProduct."',
							link_type_id='".Mage_Catalog_Model_Product_Link::LINK_TYPE_UPSELL."'
			");

// Creating Related Product link

$write->query("INSERT into $linkTable SET
							product_id='".$productId."',
							linked_product_id='".$linkProduct."',
							link_type_id='".Mage_Catalog_Model_Product_Link::LINK_TYPE_RELATED."'
			");

// Creating Crosssell Product Link
$write->query("INSERT into $linkTable SET
							product_id='".$productId."',
							linked_product_id='".$linkProduct."',
							link_type_id='".Mage_Catalog_Model_Product_Link::LINK_TYPE_CROSSSELL."'
			");

Happy Coding!

Assumming that first part, i.e. the saving of options are already done, you will now need to create a product attributes through SQL Setup

<?php
$installer = $this;
$setup = new Mage_Eav_Model_Entity_Setup('core_setup');
$installer->startSetup();
$setup->addAttribute('catalog_product', 'my_attribute', array(
    'input'         => 'multiselect',
	'required'		=> false,
    'type'          => 'text',
    'label'         => 'My Attribute Label',
    'source'        => 'mymodule/source_option',
    'backend'       => 'mymodule/backend_option',
    'global'        => Mage_Catalog_Model_Resource_Eav_Attribute::SCOPE_STORE,
    'visible'       => 1,
));
$installer->startSetup();
$installer->endSetup();

The source of the attribute is set to some Model, Ynamespace_Mymodule_Model_Source_Option. This file should look like this.

<?php
class Ynamespace_Module_Model_Source_Option
extends Mage_Eav_Model_Entity_Attribute_Source_Table
{
	public function getAllOptions()
	{
		return $this->getOptionFromTable();
	}

	private function getOptionFromTable(){
		$return=array();
		$col=Mage::getModel("modules/model")->getCollection();
		/**
		* Given that table has column as id,title,image_name
		*
		*/
		foreach($col as $row){
			array_push($return,array('label'=>$row->getTitle(),'value'=>$row->getId()));
		}
		return $return;

	}

	public function getOptionText($value)
	{
		$options = $this->getAllOptions();
		foreach ($options as $option) {
			if(is_array($value)){
				if (in_array($option['value'],$value)) {
					return $option['label'];
				}
			}
			else{
				if ($option['value']==$value) {
					return $option['label'];
				}
			}

		}
		return false;
	}
}

As you can see that the option are retrieved from the custom table in label and value pair. Remember that getAllOptions is called during product export/import as well.

Next important thing you must know is the backend model. Backend model comes into play when you save and load the product. Let me explain. Let us consider a case when you are saving product. The option of this multiselect attribute is sent in post variables as array, but the values cannot be saved as array, either you have to serialize it or implode it into string to save. So to do this change, backend model is there. Similarly, on load you need to explode or unserialize the data from the database to array. So the major functions of backend model are beforeSave() and afterLoad(), which are triggerd as product is saved or loaded. The backend model should look like this:

<?php
class Ynamespace_Modules_Model_Backend_Option
    extends Mage_Eav_Model_Entity_Attribute_Backend_Abstract
{
    /**
     * Before Attribute Save Process
     *
     * @param Varien_Object $object
     * @return Mage_Catalog_Model_Category_Attribute_Backend_Sortby
     */
    public function beforeSave($object) {
        $attributeCode = $this->getAttribute()->getName();
        if ($attributeCode == 'my_attribute') {
            $data = $object->getData($attributeCode);
            if (!is_array($data)) {
                $data = array();
            }
            $object->setData($attributeCode, join(',', $data));
        }
        return $this;
    }

    public function afterLoad($object) {
        $attributeCode = $this->getAttribute()->getName();
        if ($attributeCode == 'my_attribute') {
            $data = $object->getData($attributeCode);
            if ($data) {
                $object->setData($attributeCode, split(',', $data));
            }
        }
        return $this;
    }
}

Now you are all set, you should have the values of the multiselect attribute saved in database joined by comma seperated values and while on load those values will be exploded as array. Last thing you can do is export the product data using default profile and check if the error shows up or not regarding this attributes. Must not! I think I’ve checked its integrity with import and export as well. If it shows any, feel free to contact me.

// Directly in the PHTML where you want to show the block
<?php
echo $this->getLayout()->createBlock("module/block")->setTemplate("module/page.phtml")->toHtml();
?>

What we have actually done is just load the layout and create an instance of a block class defined inside its paramerter, then assigned a template to the block and finally echoed as html. Simple! The code above will be equivalent to what we do as following in layout and in template file.

// In layout
<block type="module/block" name="module.name" template="module/page.html"/>

<?php
// In parent PHTML
$this->getChildHtml("module.name");
?>

May be helpful!

General Work Flow (Profile)

During Import/Export there are normally two “Actors” involved. Actors may be the data source (Actor: Source) and the final destination of the data (Actor:Destination). While you are importing data into your Magento Sytem, the Source is the CSV or XML file while exporting it is the other way round. In any case (Import or Export) you need to first fetch the data from the source and process it and then save to its destination.

So Basically there are three stages in product import. But the processing part has been split into two. Processing part has been divided into two processes namely Mapper and Parser. I’ll come to the detailed description later. So along with the extended processes, lets call there are four “Actions” occuring during Import or Export.For every “Action” to run there are seperate individual Models. And the defination of all these individual Models for each Action during the Import/Export Process (Dataflow) is called “Profile“.

Here’s the basic workflow for Dataflow.

General Workflow

That was the laymen description of Dataflow, lets see what are the Jargons used in Magento to call all the Models used in Dataflow. The Models used for all actions are listed below according to how the Dataflow works.

1. Adapter
2. Parser
3. Mapper
4. Adapter (Yes twice)
5. Validator (Not Implemented yet in Magento, left for future implemention)

Adapter

To understand what is Adapter, lets see Magento as a System and all the resources it uses during Import/Export as external source. So external source in Most of the cases can be either File or your Database (DB). Other external source include Webservice. I’ven’t came across other yet. So what Adapter does is it provides the channel through which the data actually flows in/out of the Magento System. As you can see in the images below is that there is always two Adapter involved. One that reads data from the file external resource and another that saves the data into the DB external resource. Now you should be clear why I wrote Adapter twice. If you are still wondering..then you can comment below.

Case: Export

Case: Import

Magento has provides us some Default Adapter to read/write from/to external resources. Here are the Adapters listed.

Adapter For Files : Mage_Dataflow_Model_Convert_Adapter_Io

Adapter For Customer(DB) : Mage_Customer_Model_Convert_Adapter_Customer

Adapter For Product (DB) : Mage_Catalog_Model_Convert_Adapter_Product

Since the work of Adapter is to just Read or Write it has basically two Methods load() and save().

Parser

What parser does is that it just converts the raw data (Human Readable) from the source into Magento’s Format (Arrays and Setting Values of Magento’s Model) or from Magento’s Format into Human readable Format. Just to understand you can think of the CSV files seperated by comma changed into Arrays. After conversion is over it then saves the data to the Batch.Batch, what is Batch? if this is what you are thinking, here is your answer. Every row in CSV,XML or Row of the DB during the dataflow are saved as different rows in a table dataflow_batch_import or dataflow_batch_export. So if there are 100 rows in your CSV file you are importing into Magento, the batch will have 100 rows of parsed data in the table dataflow_batch_import. During the final stage of the Dataflow’s run this data is referred.

Magento provides some default Parses as well.

Parser for CSV files : Mage_Dataflow_Model_Convert_Parser_Csv

Parser for XML files : Mage_Dataflow_Model_Convert_Parser_Xml_Excel

Parser for Product : Mage_Catalog_Model_Convert_Parser_Product

Parser for Customer : Mage_Customer_Model_Convert_Parser_Customer

In all these classes there are two main Methods which deservers to be stated here. parse() and unparse(). If you are Importing then parse() should be defined in your profile, because you are parsing the data that is required by the System. In case of Exporting, you already have the parsed data of the system as source, you will then need to unparse() the data into Human readable format. You can refer to images above to understand more clearly.

So by the end of this during the profile run you will have Parsed/Unparsed data saved in the batch table, in you hand.

Mapper

Magento’s Dataflow is so flexible that you can set the header of the CSV or XML files that can mapped to the Magento’s default attributes. Let’s take an example if you want to export the product’s name into CSV with the CSV header as “Product Name”, you can specify that mapping in your profile where the Mapper will act. And in this the Magento’s attribute code “name” will be mapped to your specified “Product Name”. To do all this mapping rules, Mapper is there.

It retrives the Parsed/Unparsed Data from the batch table, we got at the end of Parser’s work, Maps to the rule we defined and then again saves back to the same table. Easy!

There is one default Mapper for all

Mapper : Mage_Dataflow_Model_Convert_Mapper_Column

With one obvious method map().

At the end of this stage you will have your Parsed/Unparsed – Mapped Data in your dataflow table.

Adapter (Again)

At last the Adapter will use the dataflow’s batch data to save(). And after all the rows of the batch table for one batch is acted upon the profile is complete.

I guess this is the general way of explaining it, please comment if I am mistake, coz I am also new to this! LOL.

Magento gives you a default interface to import or export data, but you will need the specific format of your data.It is easy to customize that as well, but today lets be interested in standard import, but with one small (Yet important) modification. The important modification in the standard code is this code will be able to options to the attribute of Select/Multiselect/Radio/Checkbox input type, while the product is being imported.

By default Magento only imports the values of the option, of any attribute, which are already avaliable. But this code can be used to create option at run time if it does not exits and assign to the product, during import. For doing this we need to first set up an Advanced Profile of Export/Import. Go to System–>Import/Export–>Advanced Profile and create new Profile. Then in the Action XML paste this.

<!--
Path=Path of the file relative to ROOT
filename= File name of the XML(MS EXCEL 2003) where import data is saved in Magento's Format
format	= XML
You can use CSV as well.
-->
<action type="dataflow/convert_adapter_io" method="load">
    <var name="type">file</var>
    <var name="path">var/import</var>
    <var name="filename"><![CDATA[products.xml]]></var>
    <var name="format"><![CDATA1]></var>
</action>

<!--
adapter= Your Model path
-->
<action type="dataflow/convert_parser_xml_excel" method="parse">
    <var name="single_sheet"><![CDATA[]]></var>
    <var name="fieldnames">true</var>
    <var name="store"><![CDATA[0]]></var>
    <var name="number_of_records">1</var>
    <var name="decimal_separator"><![CDATA[.]]></var>
    <var name="adapter">yourmodel/import</var>
    <var name="method">save</var>
</action>

The Model defined in the adapter should be like this. You can create a new module for this.

<?php
class Namespace_Module_Model_Import extends Mage_Catalog_Model_Convert_Adapter_Product {

	/**
	 * Save product (import)
	 * @param array $importData
	 * @throws Mage_Core_Exception
	 * @return bool
	 */
	public function saveRow(array $importData)
	{
		$product = $this->getProductModel()
		->reset();

		if (empty($importData['store'])) {
			if (!is_null($this->getBatchParams('store'))) {
				$store = $this->getStoreById($this->getBatchParams('store'));
			} else {
				$message = Mage::helper('catalog')->__('Skip import row, required field "%s" not defined', 'store');
				Mage::throwException($message);
			}
		}
		else {
			$store = $this->getStoreByCode($importData['store']);
		}

		if ($store === false) {
			$message = Mage::helper('catalog')->__('Skip import row, store "%s" field not exists', $importData['store']);
			Mage::throwException($message);
		}

		if (empty($importData['sku'])) {
			$message = Mage::helper('catalog')->__('Skip import row, required field "%s" not defined', 'sku');
			Mage::throwException($message);
		}
		$product->setStoreId($store->getId());
		$productId = $product->getIdBySku($importData['sku']);

		if ($productId) {
			$product->load($productId);
		}
		else {
			$productTypes = $this->getProductTypes();
			$productAttributeSets = $this->getProductAttributeSets();

			/**
			 * Check product define type
			 */
			if (empty($importData['type']) || !isset($productTypes[strtolower($importData['type'])])) {
				$value = isset($importData['type']) ? $importData['type'] : '';
				$message = Mage::helper('catalog')->__('Skip import row, is not valid value "%s" for field "%s"', $value, 'type');
				Mage::throwException($message);
			}
			$product->setTypeId($productTypes[strtolower($importData['type'])]);
			/**
			 * Check product define attribute set
			 */
			if (empty($importData['attribute_set']) || !isset($productAttributeSets[$importData['attribute_set']])) {
				$value = isset($importData['attribute_set']) ? $importData['attribute_set'] : '';
				$message = Mage::helper('catalog')->__('Skip import row, is not valid value "%s" for field "%s"', $value, 'attribute_set');
				Mage::throwException($message);
			}
			$product->setAttributeSetId($productAttributeSets[$importData['attribute_set']]);

			foreach ($this->_requiredFields as $field) {
				$attribute = $this->getAttribute($field);
				if (!isset($importData[$field]) &amp;amp;amp;&amp;amp;amp; $attribute &amp;amp;amp;&amp;amp;amp; $attribute->getIsRequired()) {
					$message = Mage::helper('catalog')->__('Skip import row, required field "%s" for new products not defined', $field);
					Mage::throwException($message);
				}
			}
		}

		$this->setProductTypeInstance($product);

		if (isset($importData['category_ids'])) {
			$product->setCategoryIds($importData['category_ids']);
		}

		foreach ($this->_ignoreFields as $field) {
			if (isset($importData[$field])) {
				unset($importData[$field]);
			}
		}

		if ($store->getId() != 0) {
			$websiteIds = $product->getWebsiteIds();
			if (!is_array($websiteIds)) {
				$websiteIds = array();
			}
			if (!in_array($store->getWebsiteId(), $websiteIds)) {
				$websiteIds[] = $store->getWebsiteId();
			}
			$product->setWebsiteIds($websiteIds);
		}

		if (isset($importData['websites'])) {
			$websiteIds = $product->getWebsiteIds();
			if (!is_array($websiteIds)) {
				$websiteIds = array();
			}
			$websiteCodes = split(',', $importData['websites']);
			foreach ($websiteCodes as $websiteCode) {
				try {
					$website = Mage::app()->getWebsite(trim($websiteCode));
					if (!in_array($website->getId(), $websiteIds)) {
						$websiteIds[] = $website->getId();
					}
				}
				catch (Exception $e) {}
			}
			$product->setWebsiteIds($websiteIds);
			unset($websiteIds);
		}

		foreach ($importData as $field => $value) {
			if (in_array($field, $this->_inventoryFields)) {
				continue;
			}
			if (in_array($field, $this->_imageFields)) {
				continue;
			}

			$attribute = $this->getAttribute($field);

			if (!$attribute) {
				continue;
			}

			$isArray = false;
			$setValue = $value;

			if ($attribute->getFrontendInput() == 'multiselect') {
				$value = split(self::MULTI_DELIMITER, $value);
				$isArray = true;
				$setValue = array();
			}

			if ($value &amp;amp;amp;&amp;amp;amp; $attribute->getBackendType() == 'decimal') {
				$setValue = $this->getNumber($value);
			}

			/**CODE MODIFICATION STARTS HERE*/

			$optionLabelArray=array();
			if ($attribute->usesSource()) {
			 $options = $attribute->getSource()->getAllOptions(false);

			 /**
			  * Update the Source of the attribute when source has no options.
			  */
			 if(count($options)<1){
			 	if($isArray){
			 		foreach($value as $key=>$subvalue){
			 			if(!in_array($subvalue,$newOptionLabelArray)){
			 				$setValue[]=$this->updateSourceAndReturnId($field,$subvalue);
			 				array_push($newOptionLabelArray,$subvalue);
			 			}
			 		}
			 	}
			 	else{
			 		if(!in_array($value,$newOptionLabelArray)){
			 			$setValue=$this->updateSourceAndReturnId($field,$value);
			 			array_push($newOptionLabelArray,$value);
			 		}
			 	}
			 }

			 /**
			  * Work on the source when it has options
			  */
			 else{
			 	/**
			 	 * This is the case of Multi-Select
			 	 */
			 	if ($isArray) {
			 		foreach ($options as $item) {
			 			/** Setting the option's ID if Label matches with the current value of XML column.*/
			 			if (in_array($item['label'], $value)) {
			 				$setValue[] = trim($item['value']);
			 				array_push($optionLabelArray,$item['label']); /**Adding Reference to worked attribute option**/
			 			}
			 		}

			 		/**
			 		 *  Checking in the current XML column value if all values were used in the above loop or not
			 		 *  If not used then they are new options value, then new option is created and then assigned.
			 		 **/

			 		foreach($value as $key=>$subvalue){
			 			if(!in_array($subvalue,$optionLabelArray)){
			 				$setValue[]=$this->updateSourceAndReturnId($field,$subvalue);
			 			}
			 		}

			 	}
			 	/**This is the case of single select**/

			 	else {
			 		$setValue = null;
			 		$newOptionLabelArray=array();
			 		foreach ($options as $item) {
			 			if ($item['label'] == $value) {
			 				$setValue = $item['value'];
			 				array_push($optionLabelArray,$item['label']); /**Adding Reference to worked attribute option**/
			 			}
			 		}
			 		/**
			 		 *  Checking in the current XML column value if all values were used in the above loop or not
			 		 *  If not used then they are new options value, then new option is created and then assigned.
			 		 **/
			 		if(!in_array($value,$optionLabelArray)){
			 			$setValue=$this->updateSourceAndReturnId($field,$value);
			 		}
			 	}
			 }
			}

			/**CODE MODIFICATION ENDS HERE*/

			$product->setData($field, $setValue);
		}

		if (!$product->getVisibility()) {
			$product->setVisibility(Mage_Catalog_Model_Product_Visibility::VISIBILITY_NOT_VISIBLE);
		}

		$stockData = array();
		$inventoryFields = isset($this->_inventoryFieldsProductTypes[$product->getTypeId()])
		? $this->_inventoryFieldsProductTypes[$product->getTypeId()]
		: array();
		foreach ($inventoryFields as $field) {
			if (isset($importData[$field])) {
				if (in_array($field, $this->_toNumber)) {
					$stockData[$field] = $this->getNumber($importData[$field]);
				}
				else {
					$stockData[$field] = $importData[$field];
				}
			}
		}
		$product->setStockData($stockData);

		$imageData = array();
		foreach ($this->_imageFields as $field) {
			if (!empty($importData[$field]) &amp;amp;amp;&amp;amp;amp; $importData[$field] != 'no_selection') {
				if (!isset($imageData[$importData[$field]])) {
					$imageData[$importData[$field]] = array();
				}
				$imageData[$importData[$field]][] = $field;
			}
		}

		foreach ($imageData as $file => $fields) {
			try {
				$product->addImageToMediaGallery(Mage::getBaseDir('media') . DS . 'import' . $file, $fields);
			}
			catch (Exception $e) {}
		}

		$product->setIsMassupdate(true);
		$product->setExcludeUrlRewrite(true);
		$product->save();

		return true;
	}

	/**
	 * Updates the source of the attribute by the current new value in the XML column, and returns
	 * the id of the newly created option.
	 *
	 * @param string $attribute_code
	 * @param string $newOption
	 * @return int|string New Option Id
	 */
	public function updateSourceAndReturnId($attribute_code,$newOption){
		$attribute_model        = Mage::getModel('eav/entity_attribute');
		$attribute_options_model= Mage::getModel('eav/entity_attribute_source_table') ;

		$attribute_code         = $attribute_model->getIdByCode('catalog_product', $attribute_code);
		$attribute              = $attribute_model->load($attribute_code);
		$attribute_table        = $attribute_options_model->setAttribute($attribute);
		try{
			$value['option'] = array(trim($newOption),trim($newOption));
			$result = array('value' => $value);
			$attribute->setData('option',$result);
			$attribute->save();
		}
		catch(Exception $e){}
		$options = $attribute_options_model->getAllOptions(false);
		foreach($options as $option)
		{
			if ($option['label'] == $newOption)
			{
				return $option['value'];
			}
		}
		return "";
	}

}

?>

Please note the /**CODE MODIFICATION ENDS HERE*/ block. Most of the description is on the code. I got it working, feel free to ask if you got any problem. I am also working on importing custom option. I’ll soon make a post in it as well.

Download Source[Updated]

Here’s the sample import sheet with request from the reader

Sample Sheet