C++ DataTable::get方法代码示例

void CompatibilityManager::resigner(const shared_ptr<IPortalDatabase> &database, shared_ptr<IdeSession> session)
{
	shared_ptr<ObjectsUser> user = session->getUser(database);
	if(user != nullptr)
	{
		Buffer signature = user->signature;
		if( (signature.getSize() == 1) && (signature.getAt(0) == 0) )
		{
			// Need re-sign.
			DataTable result;
			String sql = String::format(_S("select id,entity_author,author from os_entries where author='%S' union select id,entity_author,author from os_entries where entity_author='%S'").c_str(),user->id->toUTF16().c_str(),user->id->toUTF16().c_str());
			database->execute(sql,result);

			for(uint32 r=0;r<result.rows();r++)
			{
				String id = result.get(r,_S("id"));
				String entityAuthor = result.get(r,_S("entity_author"));
				String author = result.get(r,_S("author"));

				shared_ptr<ObjectsIObject> object = database->getPortal()->getObject(database, id.to_ascii());
				if(object != nullptr)
				{
					LanguageResult acceptable = object->acceptable(database);
					if(acceptable.empty())
					{
						if( (entityAuthor == user->id->toUTF16()) && (author == user->id->toUTF16()) )
						{
							shared_ptr<ObjectsIRevisionable> revisionable = objects_revisionable_cast(object);			
							if(revisionable != nullptr)
							{
								bool done = revisionable->signEntity(session->getPrivateKey(), database->getPortal()->getPortalID());
								OS_ASSERT(done);
							}
						}

						if(author == user->id->toUTF16())
						{
							bool done = object->sign(session->getPrivateKey(), database->getPortal()->getPortalID());							
							OS_ASSERT(done);
						}

						LanguageResult result = object->store(database);
						OS_ASSERT(result.empty());						
					}
				}
			}
		}
	}
}

void CompatibilityManager::migrateAccounts(const shared_ptr<IPortalDatabase> &database)
{
	shared_ptr<IDbConnection> globalConnection = Engine::instance()->createSystemConnection();

	DataTable result;
	String sql = _S("select * from os_accounts");
	
	database->execute(sql,result);

	for(uint32 r=0;r<result.rows();r++)
	{
		String id = result.get(r,_S("id"));

		shared_ptr<DataAccount> dataAccount(OS_NEW DataAccount());

		dataAccount->read(result[r]);

		dataAccount->description = _S("Imported from portal '") + database->getPortal()->getName();
		
		String sql = String::format(_S("select count(*) from os_accounts where id='%S'").c_str(), id.c_str());
		int nRecordExists = globalConnection->value_of(sql);
		bool alreadyExists = (nRecordExists>0); 

		DbSqlValues values;
		dataAccount->write(values);
		if(alreadyExists)
			globalConnection->executeStatement(globalConnection->prepare_update(DBTABLES::ACCOUNTS_TABLE, values, DBTABLES::ACCOUNTS::ID, Convert::toSQL(dataAccount->id)), values);
		else
		
			globalConnection->executeStatement(globalConnection->prepare_insert(DBTABLES::ACCOUNTS_TABLE, values), values);
	}
}

Profile::Profile(shared_ptr<Portal> portal, shared_ptr<IPortalDatabase> database, shared_ptr<ObjectsUser> user) : m_portal(portal),
																				 						   m_user(user)
{
	// Calcolo Score
	DataTable result;
	String sql = String::format(_S("select score, description, follow from os_snapshot_users where id='%S'").c_str(), m_user->id->toUTF16().c_str());
	database->execute(sql, result);
	if(result.hasRow(0))
	{
		// Estrae il punteggio
		m_score.setValue(result.get(0, _S("score")));
		// Estrae la descrizione
		m_score.setDescription(result.get(0, _S("description")));
		// Estrae il follow
		m_score.setFollow(result.get(0, _S("follow")));
	}
}

shared_ptr<EntitiesEntities> EntitiesEntity::getChilds(const shared_ptr<IPortalDatabase> &database, const ObjectsTypes &types, const RangeUint32 &range, shared_ptr<DbSqlSelect> select) const
{
	OS_ASSERT(select != nullptr);
	OS_ASSERT(select->count == false);

	OS_LOCK(m_cs);

	String sql;
	// Genera l'sql di caricamento dei figli
	_getSql(database, types, range, false, select, sql);

	String childsKey = getChildsKey(types);

	shared_ptr<EntitiesEntities> childs = m_childs.get(childsKey);
	// Controlla se i figli della tipologia specificata sono gi stati caricati in precedenza
	if(childs != nullptr)
	{
		if(childs->getRange() == range && childs->getSql() == sql)
			return childs;	// Se il range in cui sono stati caricati i figli e l'sql di estrazione corrispondono non serve effettuare nuovamente il caricamento...

		// Nota: se il range richiesto non coincide con quello attuale o l'sql  differente bisogna ricaricare i figli
		// Anche se il range attuale comprendesse quello richiesto bisogna comunque ricaricare i figli altrimenti dall'esterno,
		// una volta richiesto un range, scorrendo i figli non si avrebbe la certezza che siano nel range richiesto (a meno di complicare i vari giri)

		m_childs.remove(childsKey);
	}

	// Inizializza la lista dei figli prima di aprire il database (la connessione potrebbe fallire, ma la lista deve essere comunque creata)
	childs.reset(OS_NEW EntitiesEntities(const_cast <EntitiesEntity *>(this)->get_this_ptr(), sql));
	m_childs.push_back(childsKey, childs);

	DataTable result;
	database->execute(sql, result);
	for(uint32 i = 0; i < result.rows(); i++)
	{
		String child_id = result.get(i, DBTABLES::ENTITY);
		childs->push_back(child_id.to_ascii());
	}

	return childs;
}

//bool EntitiesEntity::_loadObject(const shared_ptr<IPortalDatabase> &database, shared_ptr<ObjectsIRevisionable> object)
bool EntitiesEntity::load(const shared_ptr<IPortalDatabase> &database, const EntityID & id)
{
	OS_TIMER_PERFORMANCE(TP, _S("Entity::_loadObject"));
	OS_LOCK(m_cs);

#ifndef OS_TODOCIP
	shared_ptr<ObjectsIRevisionable> object = objects_revisionable_cast(database->getPortal()->getObject(database, id.toUTF16()));
	m_primary = object;
	//OS_ASSERT(getEntityID() == id);
#endif

	if(database->getPortal()->getSnapshotManager()->m_enableEnsureLoadingEntity)
		database->getPortal()->getSnapshotManager()->ensure(database, id);

	DataTable result;
	// TOCLEAN_SNAPSHOT_SCORE
	//String sql = String::format(_S("select current,visible,score,depth,parent,section,stability_date from os_snapshot_objects where reference='%S'").c_str(), m_primary->id->toUTF16().c_str());
	String sql = String::format(_S("select type,current,visible,depth,parent,section,stability_date from os_snapshot_objects where entity='%S'").c_str(), id.toUTF16().c_str());
	database->execute(sql, result);
	if(!result.hasRow(0))
	{
		clear();
		return false;
	}
	else
	{
		ObjectID currentID = static_cast<String>(result.get(0,_S("current"))).to_ascii();
		m_type = Convert::toObjectType(static_cast<uint32>(result.get(0,_S("type"))));
		m_visible = result.get(0,_S("visible"));
		//m_score = *result.get(0,_S("score")); // TOCLEAN_SNAPSHOT_SCORE
		m_depth = result.get(0,_S("depth"));
		m_parent = static_cast<String>(result.get(0,_S("parent"))).to_ascii();
		m_section = static_cast<String>(result.get(0,_S("section"))).to_ascii();
		m_stabilityDate = String(result.get(0,_S("stability_date")));

		if(id == ObjectsSystem::instance()->getRootID())
			//m_current = objects_revisionable_cast(database->getPortal()->getObject(database, ObjectsSystem::instance()->getRootID().toObjectID()));
			m_current = ObjectsSection::getRootSection();
		else
		{		
#ifdef OS_TODOCIP
			/*
			if(currentID.empty())
				return false;
			m_current = objects_revisionable_cast(database->getPortal()->getObject(database, currentID));
			if(m_current == nullptr)
				return false;				
			*/

			if(currentID.empty() == false)
				m_current = objects_revisionable_cast(database->getPortal()->getObject(database, currentID));
#else
			if(currentID.empty())
			{
				m_current.reset();
				// OS_ASSERT(m_parent == ObjectsSystem::instance()->getSkippedID());
				// No, dato che la getEntity non fa + l'ensure, può succedere che carica un oggetto non stabilizzato.
				m_visible = false;
			}
			else
				m_current = objects_revisionable_cast(database->getPortal()->getObject(database, currentID));
#endif
		}

		return true;
	}
}

String Connection::preAnalyze(const String &sql)
{
	static boost::recursive_mutex cs;
	OS_LOCK(cs);

	// Per vedere le sql nel charts:
	// RealtimeStatsManager::signal(sql, 1, RealtimeStatsCounter::ctAbsolute, _S("status"));

	// Da notare che vengono archiviate nella os_monitor solo le query analizzate dalla "explain".
	// Una "insert", non usando indici, non viene catalogata, a meno che non abbia sotto-query.

	if(sql.find(_S("explain query plan ")) != String::npos)
		return _S("");

	if(sql.find(_S("os_monitor")) != String::npos)
		return _S("");

	static shared_ptr<Connection> connectionAnalyze = nullptr;
	if(connectionAnalyze == nullptr)
	{
		shared_ptr<Driver> driver = boost::dynamic_pointer_cast<Driver>(getDriver());
		String path = driver->getDatabasePath(_S("monitor.db"));
		if(FileSystem::instance()->exists(path) == false)
		{
			// Crea il database se non esiste
			File file;
			String msg = _S("Cannot create file '") + path + _S("'");
			OS_EXCEPT_IF(file.open(path, File::ofWrite) == false, msg.to_ascii());
		}

		connectionAnalyze.reset(OS_NEW Connection(path, getDriver()->createOptions(), getDriver()));

		int32 res = _tsqlite3_open(path.c_str(), &connectionAnalyze->m_connection);
		OS_EXCEPT_IF(res != SQLITE_OK, sqlite_last_error(connectionAnalyze->m_connection, res));

		// Creazione tabella
		String sqlCreate = _S("CREATE TABLE IF NOT EXISTS os_monitor (filename text,sql text,thread integer,conn integer,trans integer, qorder integer,qfrom integer,detail text,indexUsed text)");
		doExecute(connectionAnalyze->m_connection, sqlCreate);
	}

	// I valori dei campi li setto a ?, per poter fare delle distinct sui risultati
	String keySql = sql;
	keySql.trim();
	keySql = regex_replace(keySql, RegexManager::instance()->getRegex(_S("'(.*?)'")), _S("<s>")); // Valori dei campi
	keySql = regex_replace(keySql, RegexManager::instance()->getRegex(_S("[-+]?[0-9]*\\.?[0-9]+")), _S("<n>")); // Numeri
	keySql = keySql.replace_all(_S("\n"),_S(""));
	keySql = keySql.replace_all(_S("\r"),_S(""));
	keySql = keySql.replace_all(_S("\t"),_S(""));
	keySql = keySql.replace_all(_S("'"),_S("")); // Futile, per evitare errori nella insert nella os_monitor
	for(;;) // Comprimo gli spazi
	{
		String x = keySql;
		keySql = keySql.replace_all(_S("  "),_S(" "));
		if(x == keySql)
			break;
	}

	uint32 conn = uint32(reinterpret_cast<uint64>(this));
	boost::any threadID = PlatformManager::instance()->getCurrentThreadID();
	// Tenta un cast a uint32
	uint32 *thread = boost::any_cast<uint32>(&threadID);
	int32 trans = m_transactionId;

	DataTable result;
	doQuery(m_connection, _S("explain query plan ") + sql,result);

	for(uint32 r=0;r<result.rows();r++)
	{
		int32 order = *result.get(r,_S("order"));
		int32 from = *result.get(r,_S("from"));
		String detail = *result.get(r,_S("detail"));

		String indexUsed;
		String::size_type posWithIndex = detail.find(_S("WITH INDEX"));
		if(posWithIndex != String::npos)
		{
			indexUsed = detail.substr(posWithIndex+10);
			indexUsed = indexUsed.replace_all(_S("ORDER BY"),String::EMPTY);
			indexUsed.trim();
		}

		String sqlInsert = String::format(_S("insert into os_monitor values ('%S','%S',%u,%u,%u,%d,%d,'%S','%S')").c_str(), m_filename.c_str(), keySql.c_str(), conn, thread != nullptr ? *thread : 0, trans, order, from, detail.c_str(), indexUsed.c_str());
		doExecute(connectionAnalyze->m_connection, sqlInsert);
	}

	String trace = String::format(_S("Sqlite monitor: sql='%S',conn=%u,thread=%u,trans=%u\n").c_str(), sql.c_str(), conn, thread != nullptr ? *thread : 0, trans);
	//OS_TRACE(trace);

	//RealtimeStatsManager::signal(_S("Sqlite ") + keySql.mid(0,6), 1, RealtimeStatsCounter::ctRelative, _S("items"));
	return keySql;
}

void CompatibilityManager::renameIDS(const shared_ptr<IPortalDatabase> &database)
{
	/*
		if(id == 2) // Reputation
			newID = database->getUserReputationID(
		else if(id == 7) // Avatar
		else if(id == 14) // Vote
		else if(id == 17) // PollVote
	}
	*/

	// Reputations
	{
		DataTable result;
		String sql = _S("select id, author, reference from os_reputations");
		database->execute(sql,result);

		for(uint32 r=0;r<result.rows();r++)
		{
			String id = result.get(r,_S("id"));
			String author = result.get(r,_S("author"));
			String reference = result.get(r,_S("reference"));

			ObjectID newID = database->getUserReputationID(author.to_ascii(), reference.to_ascii());

			String sql = _S("update os_reputations set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
			sql = _S("update os_entries set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
		}
	}

	// Avatars
	{
		DataTable result;
		String sql = _S("select id, author from os_avatars");
		database->execute(sql,result);

		for(uint32 r=0;r<result.rows();r++)
		{
			String id = result.get(r,_S("id"));
			String author = result.get(r,_S("author"));
			
			ObjectID newID = database->getUserAvatarID(author.to_ascii());

			String sql = _S("update os_avatars set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
			sql = _S("update os_entries set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
		}
	}

	// Vote
	{
		DataTable result;
		String sql = _S("select id, author, reference from os_votes");
		database->execute(sql,result);

		for(uint32 r=0;r<result.rows();r++)
		{
			String id = result.get(r,_S("id"));
			String author = result.get(r,_S("author"));
			String reference = result.get(r,_S("reference"));
			
			ObjectID newID = database->getUserVoteID(author.to_ascii(), reference.to_ascii());

			String sql = _S("update os_votes set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
			sql = _S("update os_entries set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
		}
	}

	// PollVote
	{
		DataTable result;
		String sql = _S("select id, author, reference from os_polls_votes");
		database->execute(sql,result);

		for(uint32 r=0;r<result.rows();r++)
		{
			String id = result.get(r,_S("id"));
			String author = result.get(r,_S("author"));
			String reference = result.get(r,_S("reference"));
			
			ObjectID newID = database->getUserPollVoteID(author.to_ascii(), reference.to_ascii());

			String sql = _S("update os_polls_votes set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
			sql = _S("update os_entries set id=") + Convert::toSQL(newID) + _S(" where id=") + Convert::toSQL(id);
			database->execute(sql);
		}
	}
}

void IdeTableQuery::onPreRender()
{
	ControlBase::onPreRender();
	
	shared_ptr<XMLDocument> document = getDocument();
	shared_ptr<XMLNode> node_root = document->create(_S("table_query"));

	DataTable result;
	if(getPage()->getDatabase()->execute(m_sql,result))
	{
		shared_ptr<XMLNode> node_header = node_root->addChild(_S("header"));

		for(uint32 c = 0; c < result.columns(); c++)
		{
			String columnTitle = getColumnTitle(c);
			if(columnTitle.empty())
				columnTitle = result.getColumnName(c);

			shared_ptr<XMLNode> node_column = node_header->addChild(_S("column"));

			node_column->setAttributeString(_S("name"), columnTitle);

			switch(getColumnType(c))
			{
			case IdeTableQuery::ctString:
				{
					node_column->setAttributeString(_S("type"), _S("string"));
				} break;
			case IdeTableQuery::ctScore:
				{
					node_column->setAttributeString(_S("type"), _S("score"));
				} break;
			case IdeTableQuery::ctEntityID:
				{
					node_column->setAttributeString(_S("type"), _S("entity-id"));
				} break;
			case IdeTableQuery::ctObjectID:
				{
					node_column->setAttributeString(_S("type"), _S("object-id"));
				} break;
			case IdeTableQuery::ctUserID:
				{
					node_column->setAttributeString(_S("type"), _S("user-id"));
				} break;
			case IdeTableQuery::ctShortDateTime:
				{
					node_column->setAttributeString(_S("type"), _S("short-datetime"));
				} break;
			case IdeTableQuery::ctLongDateTime:
				{
					node_column->setAttributeString(_S("type"), _S("long-datetime"));
				} break;
			}
		}

		shared_ptr<XMLNode> node_data = node_root->addChild(_S("data"));

		for(uint32 r=0;r<result.rows();r++)
		{
			shared_ptr<XMLNode> node_data_row = node_data->addChild(_S("row"));

			for(uint32 c=0;c<result.columns();c++)
			{
				shared_ptr<XMLNode> node_data_row_item = node_data_row->addChild(_S("item"));

				String value = result.get(r,c);

				switch(getColumnType(c))
				{
				case IdeTableQuery::ctScore:
					{
						node_data_row_item->setAttributeString(_S("value"), String::format(_S("%1.1f").c_str(), double(result.get(r,c))));
					} break;
				case IdeTableQuery::ctEntityID:
					{
						// Sbagliata
						shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(node_data_row_item, getPage(), XMLPortalExporter::emLite));
						shared_ptr<ObjectsIObject> object = getPage()->getObject(value.to_ascii());
						if(object != nullptr)
						{
							object->exportXML(exporter);
						}
					} break;
				case IdeTableQuery::ctObjectID:
					{
						shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(node_data_row_item, getPage(), XMLPortalExporter::emLite));
						shared_ptr<ObjectsIObject> object = getPage()->getObject(value.to_ascii());
						if(object != nullptr)
						{
							object->exportXML(exporter);
						}
					} break;
				case IdeTableQuery::ctUserID:
					{
						shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(node_data_row_item, getPage(), XMLPortalExporter::emLite));
						shared_ptr<ObjectsIObject> object = getPage()->getObject(value.to_ascii());
						if(object != nullptr)
						{
							object->exportXML(exporter);
						}
//.........这里部分代码省略.........

void SearchResultsDatabase::executeQuery(shared_ptr<IPortalDatabase> database, shared_ptr<Portal> portal, shared_ptr<SearchQuery> query, const StringMap& objectsMap)
{
	clear();

	shared_ptr<DbSqlSelect> select(new DbSqlSelect(DBTABLES::SNAPSHOT_OBJECTS_TABLE));
	select->fields.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::ENTITY, DBTABLES::SNAPSHOT_OBJECTS_TABLE));
	// Se  il primo step di un groupMode, ho bisogno di estrarre anche il padre.
	if(query->getGroupMode() && (objectsMap.empty()))
		select->fields.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::PARENT, DBTABLES::SNAPSHOT_OBJECTS_TABLE));
	
	// Solo se non  specificata gi una lista di oggetti.
	// Le where si riferiscono agli oggetti singoli (ex. post), non al loro oggetto da visualizzare.
	// Quindi non  necessario specificarle nel secondo giro.
	if(objectsMap.empty())
	{
		// current != ""
		select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::CURRENT, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(String::EMPTY), DbSqlCondition::cfDifferent | DbSqlCondition::cfAnd);

		// Controlla se  stata specificata una data di creazione minima
		const DateTime &fromSubmitDate = query->convertSearchDateTime(query->getFromSubmitDateType(),query->getFromSubmitDateSpecific());
		if(fromSubmitDate.isValid())
		{
			// submit_date >= fromSubmitDate
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::SUBMIT_DATE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(fromSubmitDate), DbSqlCondition::cfMajor | DbSqlCondition::cfEqual | DbSqlCondition::cfAnd);
		}

		// Controlla se  stata specificata una data di creazione massima
		const DateTime &toSubmitDate = query->convertSearchDateTime(query->getToSubmitDateType(),query->getToSubmitDateSpecific());
		if(toSubmitDate.isValid())
		{
			// submit_date <= toSubmitDate
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::SUBMIT_DATE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(toSubmitDate), DbSqlCondition::cfMinor | DbSqlCondition::cfEqual | DbSqlCondition::cfAnd);
		}

		// Controlla se  stata specificata una data di inserimento minima
		const DateTime &fromInsertDate = query->convertSearchDateTime(query->getFromInsertDateType(),query->getFromInsertDateSpecific());
		if(fromInsertDate.isValid())
		{
			// insert_date >= fromInsertDate
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::INSERT_DATE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(fromInsertDate), DbSqlCondition::cfMajor | DbSqlCondition::cfEqual | DbSqlCondition::cfAnd);
		}

		// Controlla se  stata specificata una data di creazione massima
		const DateTime &toInsertDate = query->convertSearchDateTime(query->getToInsertDateType(),query->getToInsertDateSpecific());
		if(toInsertDate.isValid())
		{
			// insert_date <= toInsertDate
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::INSERT_DATE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(toInsertDate), DbSqlCondition::cfMinor | DbSqlCondition::cfEqual | DbSqlCondition::cfAnd);
		}

		// Non mostrare le entit virtuali. Dato che le entit virtuali hanno insertDate==null,
		select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::INSERT_DATE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(DateTime::EMPTY), DbSqlCondition::cfDifferent | DbSqlCondition::cfAnd);

		// Se non deve mostrare gli oggetti cancellati forza la visibilit ad 1
		if(query->getShowDeleted() == false)
			// visible == 1
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::VISIBLE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), Convert::toSQL(true));

		StringList types;
		for(SearchQuery::Options::const_iterator i = query->getOptions().begin(); i != query->getOptions().end(); ++i)
		{
			shared_ptr<ISearchOptions> options = i->second;
			if(options->getActive())
			{
				types.push_back(Convert::toString(options->getType()));
			}
		}

		if(types.empty() == false)
			// type in (...)
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::TYPE, DBTABLES::SNAPSHOT_OBJECTS_TABLE), types);

		// Ricerca in determinati padri
		StringList parentsList;
		query->computeParentsList(database, portal, parentsList);
		// Ci metto gli apici...
		for(StringList::iterator i = parentsList.begin(); i != parentsList.end(); ++i)
		{
			*i = _S("'") + String(*i) + _S("'");
		}
		if(!parentsList.empty())
		{
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::PARENT, DBTABLES::SNAPSHOT_OBJECTS_TABLE), parentsList);
		}

		// 0.14 RC3
		if(query->getText().substr(0,17) == _S("title-start-with:"))
		{
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::TITLE), Convert::toSQL(query->getText().substr(17) + _S("%")), DbSqlCondition::cfLike | DbSqlCondition::cfAnd);
		}

		// 0.14 RC3
		if(query->getText().substr(0,17) == _S("title-start-with:"))
		{
			select->where.add(DbSqlField(DBTABLES::SNAPSHOT_OBJECTS::TITLE), query->getText().substr(17) + _S("%"), DbSqlCondition::cfLike | DbSqlCondition::cfAnd);
		}

		// 0.12
		if( (query->getByUser().empty() == false) && (query->getByUser() != _S("*")) )
		{
//.........这里部分代码省略.........