ArchiveProcessing.php

<?php
/**
 * Piwik - Open source web analytics
 * 
 * @link http://piwik.org
 * @license http://www.gnu.org/licenses/gpl-3.0.html GPL v3 or later
 * 
 * @category Piwik
 * @package Piwik
 */

/**
 * The ArchiveProcessing module is a module that reads the Piwik logs from the DB and
 * compute all the reports, which are then stored in the database.
 * 
 * The ArchiveProcessing class is used by the Archive object to make sure the given Archive is processed and available in the DB.
 * 
 * A record in the Database for a given report is defined by
 * - idarchive	= unique ID that is associated to all the data of this archive (idsite+period+date)
 * - idsite		= the ID of the website 
 * - date1 		= starting day of the period
 * - date2 		= ending day of the period
 * - period 	= integer that defines the period (day/week/etc.). @see period::getId()
 * - ts_archived = timestamp when the archive was processed (UTC)
 * - name 		= the name of the report (ex: uniq_visitors or search_keywords_by_search_engines)
 * - value 		= the actual data
 * 
 * @package Piwik
 * @subpackage Piwik_ArchiveProcessing
 */
abstract class Piwik_ArchiveProcessing
{
	/**
	 * Flag stored at the end of the archiving
	 *
	 * @var int
	 */
	const DONE_OK = 1;
	
	/**
	 * Flag stored at the start of the archiving
	 * When requesting an Archive, we make sure that non-finished archive are not considered valid
	 *
	 * @var int
	 */
	const DONE_ERROR = 2;
	
	/**
	 * Flag indicates the archive is over a period that is not finished, eg. the current day, current week, etc.
	 * Archives flagged will be regularly purged from the DB.
	 * 
	 * @var int
	 */
	const DONE_OK_TEMPORARY = 3;
	
	/**
	 * A row is created to lock an idarchive for the current archive being processed
	 * @var string
	 */
	const PREFIX_SQL_LOCK = "locked_";
	
	/**
	 * Idarchive in the DB for the requested archive
	 *
	 * @var int
	 */
	protected $idArchive;
	
	/**
	 * Period id @see Piwik_Period::getId()
	 *
	 * @var int
	 */
	protected $periodId;
	
	/**
	 * Timestamp for the first date of the period
	 *
	 * @var int unix timestamp
	 */
	protected $timestampDateStart = null;
	
	/**
	 * Starting date of the archive
	 * 
	 * @var Piwik_Date
	 */
	protected $dateStart;
	
	/**
	 * Ending date of the archive
	 * 
	 * @var Piwik_Date
	 */
	protected $dateEnd;
	
	/**
	 * Object used to generate (depending on the $dateStart) the name of the DB table to use to store numeric values
	 * 
	 * @var Piwik_TablePartitioning
	 */
	protected $tableArchiveNumeric;
	
	/**
	 * Object used to generate (depending on the $dateStart)  the name of the DB table to use to store numeric values
	 * 
	 * @var Piwik_TablePartitioning
	 */
	protected $tableArchiveBlob;
	
	/**
	 * Minimum timestamp looked at for processed archives  
	 *
	 * @var int
	 */
	protected $minDatetimeArchiveProcessedUTC = false;

	/**
	 * Compress blobs
	 *
	 * @var bool
	 */
	protected $compressBlob;
	
	/**
	 * Is the current archive temporary. ie.
	 * - today 
	 * - current week / month / year
	 */
	protected $temporaryArchive;
	
	/**
	 * Id of the current site
	 * Can be accessed by plugins (that is why it's public)
	 * 
	 * @var int
	 */
	public $idsite	= null;
	
	/**
	 * Period of the current archive
	 * Can be accessed by plugins (that is why it's public)
	 * 
	 * @var Piwik_Period
	 */
	public $period 	= null;
	
	/**
	 * Site of the current archive
	 * Can be accessed by plugins (that is why it's public)
	 * 
	 * @var Piwik_Site
	 */
	public $site 	= null;
	
	/**
	 * @var Piwik_Segment
	 */
	protected $segment = null;
	
	/**
	 * Current time.
	 * This value is cached.
	 *
	 * @var int
	 */
	public $time	= null;

	/**
	 * Starting datetime in UTC
	 *
	 * @var string
	 */
	public $startDatetimeUTC;
	
	/**
	 * Ending date in UTC
	 *
	 * @var string
	 */
	public $strDateEnd;
	
	/**
	 * Name of the DB table _log_visit
	 *
	 * @var string
	 */
	public $logTable;
	
	/**
	 * When set to true, we always archive, even if the archive is already available.
	 * You can change this settings automatically in the config/global.ini.php always_archive_data under the [Debug] section
	 *
	 * @var bool
	 */
	public $debugAlwaysArchive = false;
	
	/**
	 * If the archive has at least 1 visit, this is set to true.
	 *
	 * @var bool
	 */
	public $isThereSomeVisits = null;
	
	protected $startTimestampUTC;
	protected $endTimestampUTC;
	
	/**
	 * Flag that will forcefully disable the archiving process. Only set by the tests.
	 */
	public static $forceDisableArchiving = false;
	
	/**
	 * Constructor
	 */
	public function __construct()
	{
		$this->time = time();
	}

	/**
	 * Returns the Piwik_ArchiveProcessing_Day or Piwik_ArchiveProcessing_Period object
	 * depending on $name period string
	 *
	 * @param string $name day|week|month|year
	 * @throws Exception
	 * @return Piwik_ArchiveProcessing Piwik_ArchiveProcessing_Day|Piwik_ArchiveProcessing_Period
	 */
	static function factory($name)
	{
		switch($name)
		{
			case 'day':
				$process = new Piwik_ArchiveProcessing_Day();		
				$process->debugAlwaysArchive = Piwik_Config::getInstance()->Debug['always_archive_data_day'];
			break;
			
			case 'week':
			case 'month':
			case 'year':
				$process = new Piwik_ArchiveProcessing_Period();
				$process->debugAlwaysArchive = Piwik_Config::getInstance()->Debug['always_archive_data_period'];
			break;

			case 'range':
				$process = new Piwik_ArchiveProcessing_Period();
				$process->debugAlwaysArchive = Piwik_Config::getInstance()->Debug['always_archive_data_range'];
			break;
			
			default:
				throw new Exception("Unknown Archiving period specified '$name'");
			break;
		}
		return $process;
	}
	
	const OPTION_TODAY_ARCHIVE_TTL = 'todayArchiveTimeToLive';
	const OPTION_BROWSER_TRIGGER_ARCHIVING = 'enableBrowserTriggerArchiving';

	static public function getCoreMetrics()
	{
		return array(
			'nb_uniq_visitors', 
			'nb_visits',
			'nb_actions', 
			'sum_visit_length',
			'bounce_count',
			'nb_visits_converted',
		);
	}
	
	static public function setTodayArchiveTimeToLive($timeToLiveSeconds)
	{
		$timeToLiveSeconds = (int)$timeToLiveSeconds;
		if($timeToLiveSeconds <= 0)
		{
			throw new Exception(Piwik_TranslateException('General_ExceptionInvalidArchiveTimeToLive'));
		}
		Piwik_SetOption(self::OPTION_TODAY_ARCHIVE_TTL, $timeToLiveSeconds, $autoload = true);
	}
	
	static public function getTodayArchiveTimeToLive()
	{
		$timeToLive = Piwik_GetOption(self::OPTION_TODAY_ARCHIVE_TTL);
		if($timeToLive !== false)
		{
			return $timeToLive;
		}
		return Piwik_Config::getInstance()->General['time_before_today_archive_considered_outdated'];
	}

	static public function setBrowserTriggerArchiving($enabled)
	{
		if(!is_bool($enabled))
		{
			throw new Exception('Browser trigger archiving must be set to true or false.');
		}
		Piwik_SetOption(self::OPTION_BROWSER_TRIGGER_ARCHIVING, (int)$enabled, $autoload = true);
		Piwik_Tracker_Cache::clearCacheGeneral();
	}

	static public function isBrowserTriggerArchivingEnabled()
	{
		$browserArchivingEnabled = Piwik_GetOption(self::OPTION_BROWSER_TRIGGER_ARCHIVING);
		if($browserArchivingEnabled !== false)
		{
			return (bool)$browserArchivingEnabled;
		}
		return (bool)Piwik_Config::getInstance()->General['enable_browser_archiving_triggering'];
	}
	
	public function getIdArchive()
	{
		return $this->idArchive;
	}
	
	/**
	 * Sets object attributes that will be used throughout the process
	 */
	public function init()
	{
		$this->idsite = $this->site->getId();
		$this->periodId = $this->period->getId();

		$this->initDates();
		
		$this->tableArchiveNumeric = self::makeNumericArchiveTable($this->period);
		$this->tableArchiveBlob = self::makeBlobArchiveTable($this->period);

		$this->minDatetimeArchiveProcessedUTC = $this->getMinTimeArchivedProcessed();
		$db = Zend_Registry::get('db');
		$this->compressBlob = $db->hasBlobDataType();
	}

	/**
	 * The archive processing classes have features that might be useful for live querying;
	 * In particular, Piwik_ArchiveProcessing_Day::query*. In order to reuse those methods
	 * outside the actual archiving or to reuse archiving code for live querying, an instance
	 * of archive processing has to be faked.
	 * 
	 * For example, this code can be used in an API method:
	 * $archiveProcessing = new Piwik_ArchiveProcessing_Day();
	 * $archiveProcessing->setSite(new Piwik_Site($idSite));
	 * $archiveProcessing->setPeriod(Piwik_Period::advancedFactory($period, $date));
	 * $archiveProcessing->setSegment(new Piwik_Segment($segment, $idSite));
	 * $archiveProcessing->initForLiveUsage(); 
	 * Then, either use $archiveProcessing->query* or pass the instance to the archiving
	 * code of the plugin. Note that even though we use Piwik_ArchiveProcessing_Day, this
	 * works for any $period and $date that has been passed to the API.
	 */
	public function initForLiveUsage() {
		$this->idsite = $this->site->getId();
		$this->initDates();
	}
	
	private function initDates() {
		$dateStartLocalTimezone = $this->period->getDateStart();
		$dateEndLocalTimezone = $this->period->getDateEnd();
		
		$dateStartUTC = $dateStartLocalTimezone->setTimezone($this->site->getTimezone());
		$dateEndUTC = $dateEndLocalTimezone->setTimezone($this->site->getTimezone());
		$this->startDatetimeUTC = $dateStartUTC->getDateStartUTC();
		$this->endDatetimeUTC = $dateEndUTC->getDateEndUTC();
		$this->startTimestampUTC = $dateStartUTC->getTimestamp();
		$this->endTimestampUTC = strtotime($this->endDatetimeUTC);		
	}
	
	/**
	 * Utility function which creates a TablePartitioning instance for the numeric
	 * archive data of a given period.
	 * 
	 * @param Piwik_Period $period The time period of the archive data.
	 * @return Piwik_TablePartitioning_Monthly
	 */
	public static function makeNumericArchiveTable($period)
	{
		$result = new Piwik_TablePartitioning_Monthly('archive_numeric');
		$result->setTimestamp($period->getDateStart()->getTimestamp());
		return $result;
	}
	
	/**
	 * Utility function which creates a TablePartitioning instance for the blob
	 * archive data of a given period.
	 * 
	 * @param Piwik_Period $period The time period of the archive data.
	 * @return Piwik_TablePartitioning_Monthly
	 */
	public static function makeBlobArchiveTable($period)
	{
		$result = new Piwik_TablePartitioning_Monthly('archive_blob');
		$result->setTimestamp($period->getDateStart()->getTimestamp());
		return $result;
	}

	public function getStartDatetimeUTC()
	{
		return $this->startDatetimeUTC;
	}
	
	public function getEndDatetimeUTC()
	{
		return $this->endDatetimeUTC;
	}
	
	public function isArchiveTemporary()
	{
		return $this->temporaryArchive;
	}
	
	/**
	 * Returns the minimum archive processed datetime to look at
	 *  
	 * @return string Datetime string, or false if must look at any archive available
	 */
	public function getMinTimeArchivedProcessed()
	{
		$this->temporaryArchive = false;
		// if the current archive is a DAY and if it's today,
		// we set this minDatetimeArchiveProcessedUTC that defines the lifetime value of today's archive
		if( $this->period->getNumberOfSubperiods() == 0
			&& ($this->startTimestampUTC <= $this->time && $this->endTimestampUTC > $this->time)
			)
		{
			$this->temporaryArchive = true;
			$minDatetimeArchiveProcessedUTC = $this->time - self::getTodayArchiveTimeToLive();
			// see #1150; if new archives are not triggered from the browser, 
			// we still want to try and return the latest archive available for today (rather than return nothing)
			if($this->isArchivingDisabled())
			{
				return false;
			}
		}
		// - if the period we are looking for is finished, we look for a ts_archived that 
		//   is greater than the last day of the archive 
		elseif($this->endTimestampUTC <= $this->time)
		{
			$minDatetimeArchiveProcessedUTC = $this->endTimestampUTC;
		}
		// - if the period we're looking for is not finished, we look for a recent enough archive
		else
		{
			$this->temporaryArchive = true;
			
			// We choose to only look at archives that are newer than the specified timeout
			$minDatetimeArchiveProcessedUTC = $this->time - self::getTodayArchiveTimeToLive();
			
			// However, if archiving is disabled for this request, we shall 
			// accept any archive that was processed today after 00:00:01 this morning
			if($this->isArchivingDisabled())
			{
				$timezone = $this->site->getTimezone();
				$minDatetimeArchiveProcessedUTC = Piwik_Date::factory(Piwik_Date::factory('now', $timezone)->getDateStartUTC())->setTimezone($timezone)->getTimestamp();
			}
		}
		return $minDatetimeArchiveProcessedUTC;
	}
	
	/**
	 * This method returns the idArchive ; if necessary, it triggers the archiving process.
	 * 
	 * If the archive was not processed yet, it will launch the archiving process.
	 * If the current archive needs sub-archives (eg. a month archive needs all the days archive)
	 *  it will recursively launch the archiving (using this loadArchive() on the sub-periods)
	 *
	 * @return int|false The idarchive of the archive, false if the archive is not archived yet
	 */
	public function loadArchive()
	{
		$this->init();
		if($this->debugAlwaysArchive)
		{
			return false;
		}
		$this->idArchive = $this->isArchived();
	
		if($this->idArchive === false)
		{
			return false;
		}
		return $this->idArchive;
	}
	
	/**
	 * @see loadArchive()
	 */
	public function launchArchiving()
	{
		if (!Piwik::getArchiveProcessingLock($this->idsite, $this->period, $this->segment))
		{
			Piwik::log('Unable to get lock for idSite = ' . $this->idsite
				. ', period = ' . $this->period->getLabel()
				. ', UTC datetime [' . $this->startDatetimeUTC . ' -> ' . $this->endDatetimeUTC . ' ]...');
			return;
		}

		$this->initCompute();
		$this->compute();
		$this->postCompute();
		// we execute again the isArchived that does some initialization work
		$this->idArchive = $this->isArchived();
		Piwik::releaseArchiveProcessingLock($this->idsite, $this->period, $this->segment);
	}
	
	/**
	 * This methods reads the subperiods if necessary, 
	 * and computes the archive of the current period.
	 */
	abstract protected function compute();
	
	abstract public function isThereSomeVisits();
	
	/**
	 * Returns the name of the archive field used to tell the status of an archive, (ie,
	 * whether the archive was created successfully or not).
	 * 
	 * @param bool $flagArchiveAsAllPlugins
	 * @return string
	 */
	public function getDoneStringFlag($flagArchiveAsAllPlugins = false)
	{
		return self::getDoneStringFlagFor(
			$this->getSegment(), $this->period, $this->getRequestedReport(), $flagArchiveAsAllPlugins);
	}

	/**
	 * Returns the name of the archive field used to tell the status of an archive, (ie,
	 * whether the archive was created successfully or not).
	 *
	 * @param Piwik_Segment $segment
	 * @param Piwik_Period $period
	 * @param string $requestedReport
	 * @param bool $flagArchiveAsAllPlugins
	 * @return string
	 */
	public static function getDoneStringFlagFor($segment, $period, $requestedReport, $flagArchiveAsAllPlugins = false)
	{
		$segmentHash = $segment->getHash();
		if(!self::shouldProcessReportsAllPluginsFor($segment, $period))
		{
			$pluginProcessed = self::getPluginBeingProcessed($requestedReport);
			if(!Piwik_PluginsManager::getInstance()->isPluginLoaded($pluginProcessed)
				|| $flagArchiveAsAllPlugins 
				)
			{
				$pluginProcessed = 'all';
			}
			$segmentHash .= '.'.$pluginProcessed;
		}
	    return 'done' . $segmentHash;
	}
	
	/**
	 * Init the object before launching the real archive processing
	 */
	protected function initCompute()
	{
		$this->loadNextIdarchive();
		$done = $this->getDoneStringFlag();
		$this->insertNumericRecord($done, Piwik_ArchiveProcessing::DONE_ERROR);
		
		// Can be removed when GeoIp is in core
		$this->logTable = Piwik_Common::prefixTable('log_visit');
		
		$temporary = 'definitive archive';
		if($this->isArchiveTemporary())
		{
			$temporary = 'temporary archive';
		}
        Piwik::log(sprintf("'%s, idSite = %d (%s), segment '%s', report = '%s', UTC datetime [%s -> %s]",
            $this->period->getLabel(),
            $this->idsite,
            $temporary,
            $this->getSegment()->getString(),
            $this->getRequestedReport(),
            $this->startDatetimeUTC,
            $this->endTimestampUTC
        ));
	}
	
	/**
	 * Post processing called at the end of the main archive processing.
	 * Makes sure the new archive is marked as "successful" in the DB
	 * 
	 * We also try to delete some stuff from memory but really there is still a lot...
	 */
	protected function postCompute()
	{
		// delete the first done = ERROR 
		$done = $this->getDoneStringFlag();
		Piwik_Query("DELETE FROM ".$this->tableArchiveNumeric->getTableName()." 
					WHERE idarchive = ? AND (name = '".$done."' OR name LIKE '".self::PREFIX_SQL_LOCK."%')",
					array($this->idArchive)
		);
		
		$flag = Piwik_ArchiveProcessing::DONE_OK;
		if($this->isArchiveTemporary())
		{
			$flag = Piwik_ArchiveProcessing::DONE_OK_TEMPORARY;
		}
		$this->insertNumericRecord($done, $flag);
	}
	
	/**
	 * Returns the name of the numeric table where the archive numeric values are stored
	 *
	 * @return string 
	 */
	public function getTableArchiveNumericName()
	{
		return $this->tableArchiveNumeric->getTableName();
	}
	
	/**
	 * Returns the name of the blob table where the archive blob values are stored
	 *
	 * @return string 
	 */
	public function getTableArchiveBlobName()
	{
		return $this->tableArchiveBlob->getTableName();
	}
	
	/**
	 * Set the period
	 *
	 * @param Piwik_Period $period
	 */
	public function setPeriod( Piwik_Period $period ) 
	{
		$this->period = $period;
	}
	
	public function setSegment( Piwik_Segment $segment) 
	{
	    $this->segment = $segment;
	}
	
	public function getSegment()
	{
	    return $this->segment;
	}
	/**
	 * Set the site
	 *
	 * @param Piwik_Site $site
	 */
	public function setSite( Piwik_Site $site )
	{
		$this->site = $site;
	}
	
	public function setRequestedReport($requestedReport)
	{
		$this->requestedReport = $requestedReport;
	}

	protected function getRequestedReport()
	{
   		return $this->requestedReport;
	}

	static public function getPluginBeingProcessed( $requestedReport )
	{
		$plugin = substr($requestedReport, 0, strpos($requestedReport, '_'));
		if(empty($plugin)
		    || !Piwik_PluginsManager::getInstance()->isPluginActivated($plugin))
	    {
	    	$pluginStr = empty($plugin) ? '' : "($plugin)";
	        throw new Exception("Error: The report '$requestedReport' was requested but it is not available at this stage. You may also disable the related plugin $pluginStr to avoid this error.");
	    }
		return $plugin;
	}
	
	/**
	 * Returns the timestamp of the first date of the period
	 *
	 * @return int
	 */
	public function getTimestampStartDate()
	{
		return $this->timestampDateStart;
	}

	// exposing the number of visits publicly (number used to compute conversions rates)
	protected $nb_visits = null;
	protected $nb_visits_converted = null;
	
	protected function setNumberOfVisits($nb_visits)
	{
		$this->nb_visits = $nb_visits;
	}
	public function getNumberOfVisits()
	{
		return $this->nb_visits;
	}
	protected function setNumberOfVisitsConverted($nb_visits_converted)
	{
		$this->nb_visits_converted = $nb_visits_converted;
	}
	public function getNumberOfVisitsConverted()
	{
		return $this->nb_visits_converted;
	}
	
	
	/**
	 * Returns the idArchive we will use for the current archive
	 *
	 * @return int IdArchive to use when saving the current Archive
	 */
	protected function loadNextIdarchive()
	{
		$table = $this->tableArchiveNumeric->getTableName();
		$dbLockName = "loadNextIdArchive.$table";
		
		$db = Zend_Registry::get('db');
		$locked = self::PREFIX_SQL_LOCK . Piwik_Common::generateUniqId();
		$date = date("Y-m-d H:i:s");
		
		if (Piwik_GetDbLock($dbLockName, $maxRetries = 30) === false)
		{
			throw new Exception("loadNextIdArchive: Cannot get named lock for table $table.");
		}
		$db->exec("INSERT INTO $table "
					." SELECT ifnull(max(idarchive),0)+1, 
								'".$locked."',
								".(int)$this->idsite.",
								'".$date."',
								'".$date."',
								0,
								'".$date."',
								0 "
					." FROM $table as tb1");
		Piwik_ReleaseDbLock($dbLockName);
        $id = $db->fetchOne("SELECT idarchive FROM $table WHERE name = ? LIMIT 1", $locked);

		$this->idArchive = $id;
	}

	/**
	 * @param string $name
	 * @param int|float $value
	 */
	public function insertNumericRecord($name, $value)
	{
		$value = round($value, 2);
		return $this->insertRecord($name, $value);
	}
	
	/**
	 * @param string $name
	 * @param string|array $values
	 * @return bool|array
	 */
	public function insertBlobRecord($name, $values)
	{
		if(is_array($values))
		{
			$clean = array();
			foreach($values as $id => $value)
			{
				// for the parent Table we keep the name
				// for example for the Table of searchEngines we keep the name 'referer_search_engine'
				// but for the child table of 'Google' which has the ID = 9 the name would be 'referer_search_engine_9'
				$newName = $name;
				if($id != 0)
				{
					$newName = $name . '_' . $id;
				}
				
				if($this->compressBlob)
				{
					$value = $this->compress($value);
				}
				$clean[] = array($newName, $value);
			}
			return $this->insertBulkRecords($clean);
		}
		
		if($this->compressBlob)
		{
			$values = $this->compress($values);
		}

		$this->insertRecord($name, $values);
		return array($name => $values);
	}
	
	protected function compress($data)
	{
		return gzcompress($data);
	}
	
	protected function insertBulkRecords($records)
	{
		// Using standard plain INSERT if there is only one record to insert
		if($DEBUG_DO_NOT_USE_BULK_INSERT = false
			|| count($records) == 1)
		{
			foreach($records as $record)
			{
				$this->insertRecord($record[0], $record[1]);
			}
			return ;
		}
		$bindSql = $this->getBindArray();
		$values = array();

		foreach($records as $record)
		{
			// don't record zero
			if(empty($record[1])) continue;

			$bind = $bindSql;
			$bind[] = $record[0]; // name
			$bind[] = $record[1]; // value
			$values[] = $bind;
			
		}
		if(empty($values)) return ;
		
		if(is_numeric($record[1]))
		{
			$table = $this->tableArchiveNumeric;
		}
		else
		{
			$table = $this->tableArchiveBlob;
		}

		Piwik::tableInsertBatch($table->getTableName(), $this->getInsertFields(), $values);
		return true;
	}
	
	protected function getBindArray()
	{
		return array(	$this->idArchive,
						$this->idsite, 
						$this->period->getDateStart()->toString('Y-m-d'), 
						$this->period->getDateEnd()->toString('Y-m-d'), 
						$this->periodId, 
						date("Y-m-d H:i:s"));
	}
	
	protected function getInsertFields()
	{
		return array('idarchive', 'idsite', 'date1', 'date2', 'period', 'ts_archived', 'name', 'value');
	}

	/**
	 * Inserts a record in the right table (either NUMERIC or BLOB)
	 * @param $name
	 * @param $value
	 * @return
	 */
	protected function insertRecord($name, $value)
	{
		// table to use to save the data
		if(is_numeric($value))
		{
			// We choose not to record records with a value of 0 
			if($value == 0)
			{
				return;
			}
			$table = $this->tableArchiveNumeric;
		}
		else
		{
			$table = $this->tableArchiveBlob;
		}
		
		// duplicate idarchives are Ignored, see http://dev.piwik.org/trac/ticket/987
		
		$query = "INSERT IGNORE INTO ".$table->getTableName()." 
					(". implode(", ", $this->getInsertFields()).")
					VALUES (?,?,?,?,?,?,?,?)";
		$bindSql = $this->getBindArray();
		$bindSql[] = $name;
		$bindSql[] = $value;
		Piwik_Query($query, $bindSql);
	}
	
	/**
	 * Returns the idArchive if the archive is available in the database.
	 * Returns false if the archive needs to be computed.
	 * 
	 * An archive is available if
	 * - for today, the archive was computed less than minDatetimeArchiveProcessedUTC seconds ago
	 * - for any other day, if the archive was computed once this day was finished
	 * - for other periods, if the archive was computed once the period was finished
	 *
	 * @return int|false
	 */
	protected function isArchived()
	{
		$bindSQL = array(	$this->idsite, 
							$this->period->getDateStart()->toString('Y-m-d'), 
							$this->period->getDateEnd()->toString('Y-m-d'), 
							$this->periodId, 
		);
		
		$timeStampWhere = '';
		
		if($this->minDatetimeArchiveProcessedUTC)
		{
			$timeStampWhere = " AND ts_archived >= ? ";
			$bindSQL[] = Piwik_Date::factory($this->minDatetimeArchiveProcessedUTC)->getDatetime();
		}

		// When a Segment is specified, we try and only process the requested report in the archive
		// As a limitation, we don't know all the time which plugin should process which report
		// There is a catch all flag 'all' appended to archives containing all reports already
		// We look for this 'done.ABCDEFG.all', or for an archive that contains only our plugin data 'done.ABDCDEFG.Referers'
		$done = $this->getDoneStringFlag();
		$doneAllPluginsProcessed = $this->getDoneStringFlag($flagArchiveAsAllPlugins = true);
		
		$sqlSegmentsFindArchiveAllPlugins = '';
		
		if($done != $doneAllPluginsProcessed)
		{
			$sqlSegmentsFindArchiveAllPlugins = "OR (name = '".$doneAllPluginsProcessed."' AND value = ".Piwik_ArchiveProcessing::DONE_OK.")
					OR (name = '".$doneAllPluginsProcessed."' AND value = ".Piwik_ArchiveProcessing::DONE_OK_TEMPORARY.")";
		}
		$sqlQuery = "	SELECT idarchive, value, name, date1 as startDate
						FROM ".$this->tableArchiveNumeric->getTableName()."
						WHERE idsite = ?
							AND date1 = ?
							AND date2 = ?
							AND period = ?
							AND ( (name = '".$done."' AND value = ".Piwik_ArchiveProcessing::DONE_OK.")
									OR (name = '".$done."' AND value = ".Piwik_ArchiveProcessing::DONE_OK_TEMPORARY.")
									$sqlSegmentsFindArchiveAllPlugins
									OR name = 'nb_visits')
							$timeStampWhere
						ORDER BY idarchive DESC";
		$results = Piwik_FetchAll($sqlQuery, $bindSQL );
		if(empty($results))
		{
			return false;
		}
		
		$idarchive = false;
		// we look for the more recent idarchive
		foreach($results as $result)
		{
			if($result['name'] == $done
				|| $result['name'] == $doneAllPluginsProcessed)
			{
				$idarchive = $result['idarchive'];
				$this->timestampDateStart = Piwik_Date::factory($result['startDate'])->getTimestamp();
				break;
			}
		}
		
		// case when we have a nb_visits entry in the archive, but the process is not finished yet or failed to finish
		// therefore we don't have the done=OK
		if($idarchive === false)
		{
			return false;
		}
		
		if($this->getPluginBeingProcessed($this->getRequestedReport()) == 'VisitsSummary')
		{
			$this->isThereSomeVisits = false;
		}
		
		// we look for the nb_visits result for this most recent archive
		foreach($results as $result)
		{
			if($result['name'] == 'nb_visits' 
				&& $result['idarchive'] == $idarchive)
			{
				$this->isThereSomeVisits = ($result['value'] > 0);
				$this->setNumberOfVisits($result['value']);
				break;
			}
		}
		return $idarchive;
	}

	/**
	 * Returns true if, for some reasons, triggering the archiving is disabled.
	 * Note that when a segment is passed to the function, archiving will always occur 
	 * (since segments are by default not pre-processed)
	 *
	 * @return bool
	 */
	public function isArchivingDisabled()
	{
		return self::isArchivingDisabledFor($this->getSegment(), $this->period);
	}
	
	public static function isArchivingDisabledFor($segment, $period)
	{
        if($period->getLabel() == 'range') {
            return false;
        }
        $processOneReportOnly = !self::shouldProcessReportsAllPluginsFor($segment, $period);
        $isArchivingDisabled = !self::isRequestAuthorizedToArchive();

        if($processOneReportOnly)
        {
            // When there is a segment, archiving is not necessary allowed
            // If browser archiving is allowed, then archiving is enabled
            // if browser archiving is not allowed, then archiving is disabled
            if(!$segment->isEmpty()
                && $isArchivingDisabled
                && Piwik_Config::getInstance()->General['browser_archiving_disabled_enforce']
        )
            {
                Piwik::log("Archiving is disabled because of config setting browser_archiving_disabled_enforce=1");
                return true;
            }
            return false;
        }
		return $isArchivingDisabled;
	}
	
	protected static function isRequestAuthorizedToArchive()
	{
		return !self::$forceDisableArchiving &&
				(self::isBrowserTriggerArchivingEnabled()
				 || Piwik_Common::isPhpCliMode()
				 || (Piwik::isUserIsSuperUser() 
					&& Piwik_Common::isArchivePhpTriggered()))
					;
	}

	/**
	 * Returns true when
	 * - there is no segment and period is not range
	 * - there is a segment that is part of the preprocessed [Segments] list
	 * @param Piwik_Segment $segment
	 * @param Piwik_Period $period
	 * @return bool
	 */
	protected function shouldProcessReportsAllPlugins($segment, $period)
	{
		return self::shouldProcessReportsAllPluginsFor($segment, $period);
	}

	/**
	 * @param Piwik_Segment $segment
	 * @param Piwik_Period $period
	 * @return bool
	 */
	protected static function shouldProcessReportsAllPluginsFor($segment, $period)
	{
		if($segment->isEmpty() && $period->getLabel() != 'range')
		{
			return true;
		}
		
		$segmentsToProcess = Piwik::getKnownSegmentsToArchive();
		if(!empty($segmentsToProcess))
		{
			// If the requested segment is one of the segments to pre-process
			// we ensure that any call to the API will trigger archiving of all reports for this segment
			$segment = $segment->getString();
			if(in_array($segment, $segmentsToProcess))
			{
				return true;
			}
		}
		return false;
	}

	/**
	 * When a segment is set, we shall only process the requested report (no more).
	 * The requested data set will return a lot faster if we only process these reports rather than all plugins.
	 * Similarly, when a period=range is requested, we shall only process the requested report for the range itself.
	 * 
	 * @param string $pluginName
	 * @return bool
	 */
	public function shouldProcessReportsForPlugin($pluginName)
	{
		if($this->shouldProcessReportsAllPlugins($this->getSegment(), $this->period))
		{
			return true;
		}
		
		// If any other segment, only process if the requested report belong to this plugin
		// or process all plugins if the requested report plugin couldn't be guessed
		$pluginBeingProcessed = self::getPluginBeingProcessed($this->getRequestedReport());
		return $pluginBeingProcessed == $pluginName
				|| !Piwik_PluginsManager::getInstance()->isPluginLoaded($pluginBeingProcessed)
				; 
	}
	
}