Location: PHPKode > scripts > Osiris Core > osiris-core/core.Osiris.php
<?php
/*******************************************************************************

   XXXXXXXX     XXXXXXXX     XXXXXXXX    XXXXXXXXX     XXXXXXXX     XXXXXXXX
  XXXXXXXXXX   XXXXXXXXXX   XXXXXXXXXX   XXXXXXXXXX   XXXXXXXXXX   XXXXXXXXXX
  XX      XX   XX               XX       XX      XX       XX       XX      
  XX      XX   XXXXXXXXX        XX       XXXXXXXXXX       XX       XXXXXXXXX
  XX      XX    XXXXXXXXX       XX       XXXXXXXXX        XX        XXXXXXXXX
  XX      XX           XX       XX       XX     XX        XX               XX
  XXXXXXXXXX   XXXXXXXXXX   XXXXXXXXXX   XX      XX   XXXXXXXXXX   XXXXXXXXXX
   XXXXXXXX     XXXXXXXX     XXXXXXXX    XX      XX    XXXXXXXX     XXXXXXXX

********************************************************************************
O S I R I S  |  C O R E                                  http://core.brajola.com
********************************************************************************
Este é o núcleo principal da plataforma OSIRIS. Com ele você pode realizar
qualquer tarefa que envolva bancos de dados e formulários de consulta de forma
rápida e fácil apenas instanciando esta classe e definindo alguns padrões de
conexão ao seu banco de dados.

Este arquivo pode ser utilizado da forma que você quiser desde que mantenha as
informações sobre o autor conforme a GPL que está anexa no final no arquivo.

Se você utiliza um servidor diferente do especificado neste arquivo, acesse o
endereço http://classes.brajola.com e verá os servidores disponíveis para
download. Atualmente existem classes para os servidores MySQL, PostGreSQL,
Oracle, Microsoft SQL Server, dBase, Firebird / Interbase, Frontbase, IBM DB2,
Informix, Ingres, MaxDB, mSQL, OvrimosSQL, Paradox, SQLite.

Em caso de bugs no código-fonte, contate o autor no endereço abaixo descrito.

********************************************************************************
Desenvolvido por Brajola <hide@address.com>
*******************************************************************************/

/* Inicializa a Sessão */
session_start();

/* Mostrar Todos os Erros */
error_reporting(E_ALL);

/* Definição da Classe Principal */
class Osiris
{
	/*
	HOSTNAME: string
	Nome ou IP do Servidor
	*/
	private $HOSTNAME;
	
	/*
	USERNAME: string
	Usuário do Banco de Dados
	*/
	private $USERNAME;
	
	/*
	PASSWORD: string
	Senha do Usuário
	*/
	private $PASSWORD;
	
	/*
	DATABASE: string
	Nome do Banco de Dados
	*/
	private $DATABASE;
	
	/*
	BUFFERED: boolean
	Consultas em Buffer
	*/
	private $BUFFERED;
	
	/*
	BUTTONCONF: array
	Configurações dos botões
	*/
	public $BUTTONCONF;
	
	/*
	CONNECTED: boolean
	Status da Conexão
	*/
	private $CONNECTED;
	
	/*
	DEBUGMODE: boolean
	Modo de Depuração
	*/
	private $DEBUGMODE;
	
	/*
	DCHARSET: string
	Conjunto de Caracteres
	*/
	private $DCHARSET;
	
	/***************************************************************************
	__CONSTRUCT
	Construção da Classe
	****************************************************************************
	* Se for utilizar a classe com o método de depuração ativado, declare da
	seguinte forma:
	
	$DB = new DB(true);
	
	$DebugMode: boolean
	***************************************************************************/
	function __construct( $DebugMode = false )
	{
		/* Modo de Depuração da Classe */
		$this->DEBUGMODE = $DebugMode;
		
		/* Nome do Servidor */
		$this->HOSTNAME = "localhost";
		$this->Debug("Configuring Server Address");
		
		/* Nome do Usuário */
		$this->USERNAME = "brajola_brajola";
		$this->Debug("Configuring Server Username");
		
		/* Senha do Usuário */
		$this->PASSWORD = "h4n6iui0";
		$this->Debug("Configuring User Password");

		/* Nome do Banco de Dados */
		$this->DATABASE = "brajola_teste";
		$this->Debug("Configuring Database Name");
		
		/* Consultas em Buffer */
		$this->BUFFERED = true;
		$this->Debug("Configuring Buffered Queries");
		
		/* Conjunto de Caracteres da Conexão */
		$this->DCHARSET = 'latin1_swedish_ci';
		$this->Debug("Configuring Connection Charset");
		
		/* Configurações dos Botões da Tabela */
		$this->BUTTONCONF = array(
			
			/* Botão Detalhes */
			array("Detalhes", "botao", "details.php?id="),
				
			/* Botão Editar */
			array("Editar", "botao", "edit.php?id="),
			
			/* Botão Remover */
			array("Remover", "botao", "delete.php?id=")
		);
		
		$this->Debug("Configuring Table Button Options");
		
		/* Conexão ao Banco de Dados */
		$this->CONNECTED = $this->DBConnect();
	}
	
	/***************************************************************************
	DEBUG
	Saída de Depuração
	****************************************************************************
	Este função não deve ser utilizada em ambiente de produção por enviar saídas
	assíncronas de buffer.
	
	$DebugMessage: string
	***************************************************************************/
	private function Debug( $DebugMessage = null )
	{
		/* Se o modo de depuração estiver sendo utilizado */
		if($this->DEBUGMODE){
			
			/* Saída de buffer */
			print(date("d/m/Y - H:i:s")."<br /><strong>Debug Out: </strong>".
			$DebugMessage."<br />\n");
		}
	}
	
	/***************************************************************************
	SETCHARSET
	Mudança de Conjunto de Caracteres
	****************************************************************************
	Para utilizar esta função, verifique o conjunto de caracteres do seu banco
	de dados.
	***************************************************************************/
	private function SetCharset()
	{
		/* Modifica o conjunto de caracteres */
		$SQL_Statement = "SET NAMES '".$this->DCHARSET."'";
		mysql_query($SQL_Statement);

		/* Debug da função */
		$this->Debug("Set Connection Charset: ".$this->DCHARSET);
	}
	
	/***************************************************************************
	DBCONNECT
	Conexão ao Servidor
	****************************************************************************
	Não modifique o escopo da função, deve ser sempre private para evitar
	ataques XSS à classe.
	***************************************************************************/
	private function DBConnect()
	{
		/* Se não conseguir se conectar */
		if(!mysql_connect($this->HOSTNAME, $this->USERNAME, $this->PASSWORD)){
			return false;
		}
		
		/* Se não conseguir selecionar o banco de dados */
		if(!mysql_select_db($this->DATABASE)){
			return false;
		}
		
		/* Debug da função */
		$this->Debug("Connected to: ".$this->HOSTNAME);
		$this->Debug("Selected Database: ".$this->DATABASE);
		
		/* Setar conjunto de caracteres */
		$this->SetCharset();

		return true;
	}
	
	/***************************************************************************
	DBQUERY
	Consulta ao Banco de Dados
	****************************************************************************
	Função principal de consulta ao banco de dados. Deve ser utilizada apenas
	por classes herdeiras. No caso de utilizar diretamente, modifique o escopo
	para public.
	
	$SQL_Statement:	string
	$Return_Type:	int
	$Titles:		boolean
	***************************************************************************/
	public function DBQuery(
		$SQL_Statement,
		$Return_Type,
		$Titles
	){
		/* Adicionar barras invertidas na instrução */
		addslashes($SQL_Statement);
		
		/* Consultas com Buffer */
		if($this->BUFFERED){
			$Result = mysql_query($SQL_Statement);
		}else{
			
			/* Consultas Sem Buffer */
			$Result = mysql_unbuffered_query($SQl_Statement);
		}
		
		/* Se não retornar nenhum resultado */
		if(!$Result){
		
			/* Debug da função */
			$this->Debug("Query Error: ".$SQL_Statement);
			
			return false;
		}
		
		/* Debug da função */
		$this->Debug("Query Success: ".$SQL_Statement);
		
		/* Se não precisar retornar resultados, envia TRUE */
		if($Return_Type == 0){
			return true;
		}else{
			
			/* Array de Dados */
			$DataArray = array();
			
			/* Se for selecionado enviar os títulos de campos */
			if($Titles){
				
				/* Melhor que jogar o count direto no loop */
				$DataCount = mysql_num_fields($Result);
				
				/* Atribui os títulos ao array */
				for($i=0;$i<$DataCount;$i++){
					$DataArray[0][] = mysql_field_name($Result,$i);
				}
			}
			
			/* Enquanto houver dados, popula o array... */
			while($DataItem = mysql_fetch_row($Result)){
				array_push($DataArray, $DataItem);
			}
			
			/* Saída de Buffer */
			return $DataArray;
		}
	}
	
	/***************************************************************************
	DBTABLE
	Tabela com Dados
	****************************************************************************
	Função que retorna uma tabela de dados baseada em argumentos.
	
	$SQL_Statement:	string
	$Table_ID:		string
	$Table_Class:	string
	$Send_Titles:	boolean
	$Buttons:		array() > boolean (Ex: array(true,false,true))
	***************************************************************************/
	public function DBTable(
		$SQL_Statement,
		$Table_ID,
		$Table_Class,
		$Send_Titles,
		$Buttons = array()
	){
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, $Send_Titles);
		
		/* Contador dos dados */
		$DataCount = count($DataArray);
		
		/* Se houver dados */
		if($DataCount == 1){
			
			/* Debug da função */
			$this->Debug("Table Data Error: ".$SQL_Statement);
			return false;
		}
		
		/* Início da criação da tabela */
		$Table_Data = "<table name='".$Table_ID."' id='".$Table_ID."' class='".
		$Table_Class."'>\n";
		
		/* Para cada linha de registro */
		for($i=0;$i<$DataCount;$i++){
			
			/* Nova linha */
			$Table_Data.="<tr>";
			
			/* Contagem de colunas */
			$Field_Count = count($DataArray[$i]);
			
			/* Para cada coluna */
			for($j=0;$j<$Field_Count;$j++){
				
				/* Se for necessário enviar títulos de colunas */
				if($Send_Titles and $i == 0){
					
					/* Pode ser trocado por uma TD com classe diferente */
					$Table_Data.="<th>".$DataArray[$i][$j]."</th>";
				}else{
					
					/* TD normal de dados */
					$Table_Data.="<td>".$DataArray[$i][$j]."</td>";					
				}
			}
			
			/* Nova coluna */
			$Table_Data.="<td>";
			
			/* Botões da Tabela */
			for($k=0;$k<3;$k++){
				
				/* Se o botão for selecionado */
				if($Buttons[$k]){
					
					/* Padrão de link */
					$Pattern = "<a href='LINK' class='CLASS'>TITLE</a> ";
					
					/* Link da página do botão */
					$Pattern = str_replace("LINK", $this->BUTTONCONF[$k][2].
					$DataArray[$i][0],$Pattern);
					
					/* Classe CSS do botão */
					$Pattern = str_replace("CLASS", $this->BUTTONCONF[$k][1],
					$Pattern);
					
					/* Título do Botão */
					$Pattern = str_replace("TITLE", $this->BUTTONCONF[$k][0],
					$Pattern);
					
					/* Enviar Títulos */
					if($Send_Titles and $i>0){
						$Table_Data.=$Pattern;
					}
					
					/* Não enviar Títulos */
					if(!$Send_Titles){
						$Table_Data.=$Pattern;
					}
				}
			}
			
			/* Fecha coluna */
			$Table_Data.="</td>";
			
			/* Fecha linha */
			$Table_Data.="</tr>\n";
		}
		
		/* Fecha tabela */
		$Table_Data.="<table>\n";
		
		/* Debug da função */
		$this->Debug("Table Data Created: ".$SQL_Statement);
		
		/* Saída de buffer */
		return $Table_Data;
	}
	
	/***************************************************************************
	DB2XML
	Formata uma consulta SQL para XML
	****************************************************************************
	Retorna um arquivo XML baseado em uma consulta SQL.
	
	*** Atenção, não utilize esta classe com o modo de depuração, pode não ter
	resultados agradáveis como erros de header e cabeçalhos enviados.
	
	$SQL_Statement: string
	***************************************************************************/
	public function DB2XML( $SQL_Statement )
	{
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, true);
		
		/* Total de linhas */
		$DataCount = count($DataArray);
		
		/* Total de colunas */
		$ColCount = count($DataArray[0]);
		
		/* Headers XML */
		$XMLData = '<?xml version="1.0" encoding="ISO-8859-1"?>';
		
		/* Abertura de dados */
		$XMLData.="\n<xmldata>\n";
		
		/* Abertura de titulo */
		$XMLData.="<names>\n";
		
		/* Para cada coluna de título */
		for($j=0;$j<$ColCount;$j++){
		
			/* Linha de título */
			$XMLData.="<titname>".$DataArray[0][$j]."</titname>\n";
		}
		
		/* Fechamento de título */
		$XMLData.="</names>\n";
				
		/* Para cada linha de dados */
		for($i=1;$i<$DataCount;$i++){
			
			/* Abertura da linha de dados */
			$XMLData.="<dataline>\n";
			
			/* Para cada coluna de dados */
			for($j=0;$j<$ColCount;$j++){
			
				/* Dados da coluna */
				$XMLData.="<".$DataArray[0][$j].">".$DataArray[$i][$j]."</".$DataArray[0][$j].">\n";
			}
			
			/* Fechamento da linha */
			$XMLData.="</dataline>\n";
		}
		
		/* Fechamento de dados */
		$XMLData.="</xmldata>\n";
		
		/* Saída de buffer */
		header('Content-Type: application/xml');
		print $XMLData;
	}
		
	/***************************************************************************	
	Texto de Banco de Dados
	****************************************************************************
	Retorna um texto baseado em uma consulta SQL
	
	$SQL_Statement: string
	***************************************************************************/
	public function DBText( $SQL_Statement )
	{
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, false);
		
		/* Debug da função */
		$this->Debug("Database Text Created: ".$SQL_Statement);
		
		/* Saída de buffer */
		return $DataArray[0][0];
	}
	
	/***************************************************************************
	DBDIV
	DIV de Banco de Dados
	****************************************************************************
	Retorna uma DIV baseada em uma consulta SQL
	
	$SQL_Statement: string
	***************************************************************************/
	public function DBDIV( $SQL_Statement,$DIVClass )
	{
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, false);
		
		/* Debug da função */
		$this->Debug("Database DIV Created: ".$SQL_Statement);
		
		/* Saída de buffer */
		return "<div class='".$DIVClass."'>".$DataArray[0][0]."</div>";
	}
	
	/***************************************************************************
	DBLISTTABLES
	Listar Tabelas
	****************************************************************************
	Lista todas as tabelas do banco de dados selecionado
	***************************************************************************/
	protected function DBListTables()
	{
		/* Debug da função */
		$this->Debug("Listing Tables Completed");
		
		/* Saída de buffer */
		return $this->Query("SHOW TABLES", 0, false);		
	}
	
	/***************************************************************************
	DBOPTIMIZETABLE
	Otimizar Tabela
	****************************************************************************
	Otimiza uma tabela do sistema para melhor desempenho
	
	$Table_Name: string
	***************************************************************************/
	protected function DBOptimizeTable( $Table_Name )
	{
		/* Debug da função */
		$this->Debug("Otimizing Table: ".$Table_Name);
		
		/* Saída de buffer */
		return $this->Query("OPTIMIZE TABLE '".$Table_Name."'", 0, false);
	}
	
	/***************************************************************************
	DBCREATETABLE
	Criar Tabela
	****************************************************************************
	Cria uma nova tabela no banco de dados
	
	$ArrayTableDefs: array()
	***************************************************************************/
	protected function DBCreateTable( $ArrayTableDefs )
	{
		
		$ArrayCount = count($ArrayTableDefs);
		
		for($i=0;$i<$ArrayCount;$i++){
			$TableColumns.="";
			//Falta Terminar
		}
	
		$SQL_Statement = "CREATE TABLE '".$ArrayTableDefs[0]."' (".
		$TableColumns.")";
		
		print($SQL_Statement);
		
		$this->Debug("Table Created: ".$ArrayTableDefs[0]);
	}
	
	/***************************************************************************
	DBDROPTABLE
	Apagar Tabela
	****************************************************************************
	Remove uma tabela do banco de dados
	
	$Table_Name: string
	***************************************************************************/
	protected function DBDropTable( $Table_Name = null )
	{
		/* Debug da função */
		$this->Debug("Table Dropped: ".$Table_Name);
		
		/* Saída de buffer */
		return $this->Query("DROP TABLE '".$Table_Name."'", 0, false);
	}
	
	/***************************************************************************
	FORMTEXTBOX
	****************************************************************************
	Monta um textbox com base em uma consulta ao banco de dados
	
	$SQL_Statement:	string
	$Control_Id:	string
	$Control_Class:	string
	***************************************************************************/
	public function FormTextBox(
		$SQL_Statement,
		$Control_Id,
		$Control_Class
	){
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, false);
		
		/* Saída de buffer */
		print("<input type='text' name='".$Control_Id."' id='".$Control_Id.
		"' value='".$DataArray[0][0]."' class='".$Control_Class."'>");
		
		/* Debug da função */
		$this->Debug("Input TextBox Created: ".$SQL_Statement);
	}
	
	/***************************************************************************
	FORMTEXTAREA
	Monta uma textarea com base em uma consulta ao banco de dados
	****************************************************************************
	$SQL_Statement:	string
	$Control_Id:	string
	$Control_Class:	string
	***************************************************************************/
	public function FormTextArea(
		$SQL_Statement,
		$Control_Id,
		$Control_Class
	){
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, false);
		
		/* Saída de buffer */
		print("<textarea id='".$Control_Id."' name='".$Control_Id."' class='".
		$Control_Class."'>".$DataArray[0][0]."</textarea>");
	
		/* Debug da função */
		$this->Debug("Input TextArea Created: ".$SQL_Statement);
	}
	
	/***************************************************************************
	FORMSELECT
	Monta um select com base em uma consulta ao banco de dados
	****************************************************************************
	$SQL_Statement:	string
	$Control_Id:	string
	$Control_Class:	string
	***************************************************************************/
	public function FormSelect(
		$SQL_Statement,
		$Control_Id,
		$Control_Class,
		$Selected = 0
	){
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, false);
		
		/* Contagem dos registros */
		$DataCount = count($DataArray);
		
		/* Início da saída */
		print("<select name='".$Control_Id."' id='".$Control_Id."' class='".
		$Control_Class."'>");
		
		/* Para cada registro */
		for($i=0;$i<$DataCount;$i++){
			
			/* Se for igual ao item selecionado */
			if($DataArray[0][0] == $Selected){
				$Selected = "selected";
			}else{
				$Selected = "";
			}
			
			/* Saída principal de buffer */
			print("<option ".$Selected." value='".$DataArray[$i][0]."'>".
			$DataArray[$i][1]."</option>");
		}
		
		/* Fechando saída de buffer */
		print("</select>");
		
		/* Debug da função */
		$this->Debug("Input Select Created: ".$SQL_Statement);
	}
	
	/***************************************************************************
	FORMLIST
	Monta um listbox com base em uma consulta ao banco de dados
	****************************************************************************
	$SQL_Statement:	string
	$Control_Id:	string
	$Control_Class:	string
	***************************************************************************/
	public function FormList(
		$SQL_Statement,
		$Control_Id,
		$Control_Class,
		$Selected = 0
	){
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, false);
		
		/* Contaem dos registros */
		$DataCount = count($DataArray);
		
		/* Início da saída de buffer */
		print("<select name='".$Control_Id."' id='".$Control_Id."' class='".
		$Control_Class."'>");
		
		/* Para cada registro */
		for($i=0;$i<$DataCount;$i++){
			
			/* Se for igual ao item selecionado */
			if($DataArray[0][0] == $Selected){
				$Selected = "selected";
			}else{
				$Selected = "";
			}
			
			/* Saída principal de buffer */
			print("<option ".$Selected." value='".$DataArray[$i][0]."'>".
			$DataArray[$i][1]."</option>");
		}
		
		/* Fim da saída de buffer */
		print("</select>");
		
		/* Debug da função */
		$this->Debug("Input ListBox Created: ".$SQL_Statement);
	}
	
	/***************************************************************************
	FORMCHECKBOX
	Monta um checkbox com base em uma consulta ao banco de dados
	****************************************************************************
	$SQL_Statement:	string
	$Control_Id:	string
	$Control_Class:	string
	***************************************************************************/
	public function FormCheckBox(
		$SQL_Statement,
		$Control_Id,
		$Control_Class
	){
		/* Consulta normal */
		$DataArray = $this->DBQuery($SQL_Statement, 1, false);
		
		//Falta Implementar
		
		/* Debug da função */
		$this->Debug("Input CheckBox Created: ".$SQL_Statement);
	}
	
	/***************************************************************************
	TEST
	Testa a classe em busca de erros ou configurações
	***************************************************************************/
	public function Test()
	{
		/* Consulta Normal */
		$SQL = "
		SELECT
			cod_teste as 'Code',
			nome as 'Name',
			descricao as 'Description'
		FROM
			teste";
		
		/* Teste de Função */
		print("<h2>DBQuery()</h2>");
		print_r($this->DBQuery($SQL, 1, true));
	
		/* Teste de Função */
		print("<h2>DBTable()</h2>");
		print($this->DBTable($SQL, "resumo", "tabela", true, 
		array(true,true,true)));
		
		/* Teste de Função */
		print("<h2>DBText()</h2>");
		print($this->DBText("select nome from teste"));
		
		/* Teste de Função */
		print("<h2>DBDIV()</h2>");
		print($this->DBDIV("select nome from teste", "none"));
		
		/* Teste de Função */
		print("<h2>FormTextBox()</h2>");
		$this->FormTextBox("select nome from teste", "box", "box");
		
		/* Teste de Função */
		print("<h2>FormTextArea()</h2>");
		$this->FormTextArea("select nome from teste", "box", "box");
		
		/* Teste de Função */
		print("<h2>FormSelect()</h2>");
		$this->FormSelect("select cod_teste, nome from teste", "box", "box", 0);
		
		/* Teste de Função */
		print("<h2>FormList()</h2>");
		$this->FormList("select cod_teste, nome from teste", "box", "box");
		
		/* Teste de Função */
		print("<h2>FormCheckBox()</h2>");
		$this->FormCheckBox("select nome from teste", "box", "box");

		/* Código-fonte da página */
		//highlight_file("core.Osiris.php");
		
		/* Copyright da Classe */
		print("<hr>");
		print("Desenvolvido por Brajola - hide@address.com");
	}
}

/*******************************************************************************
		      LICENÇA PÚBLICA GERAL GNU
		       Versão 2, junho de 1991

 This is an unofficial translation of the GNU General Public License
 into Brazilian Portuguese. It was not published by the Free Software
   Foundation, and does not legally state the distribution terms for
   software that uses the GNU GPL -- only the original English text of
   the GNU GPL does that. However, we hope that this translation will
  help Brazilian Portuguese speakers understand the GNU GPL better.

  Esta é uma tradução não-oficial da Licença Pública Geral GNU ("GPL
  GNU") para o português do Brasil. Ela não foi publicada pela Free
Software Foundation, e legalmente não afirma os termos de distribuição
 de software que utiliza a GPL GNU -- apenas o texto original da GPL
 GNU, em inglês, faz isso. Contudo, esperamos que esta tradução ajude
 aos que utilizam o português do Brasil a entender melhor a GPL GNU.

   Copyright (C) 1989, 1991 Free Software Foundation, Inc. 675 Mass Ave,
		        Cambridge, MA 02139, USA

A qualquer pessoa é permitido copiar e distribuir cópias desse
documento de licença, desde que sem qualquer alteração.

			      Introdução

  As licenças de muitos software são desenvolvidas para restringir sua
liberdade de compartilhá-lo e mudá-lo. Contrária a isso, a Licença
Pública Geral GNU pretende garantir sua liberdade de compartilhar e
alterar software livres -- garantindo que o software será livre e
gratuito para os seus usuários. Esta Licença Pública Geral aplica-se à
maioria dos software da Free Software Foundation e a qualquer outro
programa cujo autor decida aplicá-la. (Alguns outros software da FSF
são cobertos pela Licença Pública Geral de Bibliotecas, no entanto.)
Você pode aplicá-la também aos seus programas.

  Quando nos referimos a software livre, estamos nos referindo a
liberdade e não a preço. Nossa Licença Pública Geral foi desenvolvida
para garantir que você tenha a liberdade de distribuir cópias de
software livre (e cobrar por isso, se quiser); que você receba o
código-fonte ou tenha acesso a ele, se quiser; que você possa mudar o
software ou utilizar partes dele em novos programas livres e
gratuitos; e que você saiba que pode fazer tudo isso.

  Para proteger seus direitos, precisamos fazer restrições que impeçam
a qualquer um negar estes direitos ou solicitar que você deles
abdique. Estas restrições traduzem-se em certas responsabilidades para
você, se você for distribuir cópias do software ou modificá-lo.

  Por exemplo, se você distribuir cópias de um programa, gratuitamente
ou por alguma quantia, você tem que fornecer aos recebedores todos os
direitos que você possui. Você tem que garantir que eles também
recebam ou possam obter o código-fonte. E você tem que mostrar-lhes
estes termos para que eles possam conhecer seus direitos.

  Nós protegemos seus direitos em dois passos: (1) com copyright do
software e (2) com a oferta desta licença, que lhe dá permissão legal
para copiar, distribuir e/ou modificar o software.

  Além disso, tanto para a proteção do autor quanto a nossa,
gostaríamos de certificar-nos que todos entendam que não há qualquer
garantia nestes software livres. Se o software é modificado por alguém
mais e passado adiante, queremos que seus recebedores saibam que o que
eles obtiveram não é original, de forma que qualquer problema
introduzido por terceiros não interfira na reputação do autor
original.

  Finalmente, qualquer programa é ameaçado constantemente por patentes
de software. Queremos evitar o perigo de que distribuidores de
software livre obtenham patentes individuais, o que tem o efeito de
tornar o programa proprietário. Para prevenir isso, deixamos claro que
qualquer patente tem que ser licenciada para uso livre e gratuito por
qualquer pessoa, ou então que nem necessite ser licenciada.

  Os termos e condições precisas para cópia, distribuição e
modificação se encontram abaixo:

		      LICENÇA PÚBLICA GERAL GNU
      TERMOS E CONDIÇÕES PARA CÓPIA, DISTRIBUIÇÃO E MODIFICAÇÃO

  0. Esta licença se aplica a qualquer programa ou outro trabalho que
contenha um aviso colocado pelo detentor dos direitos autorais
informando que aquele pode ser distribuído sob as condições desta
Licença Pública Geral. O "Programa" abaixo refere-se a qualquer
programa ou trabalho, e "trabalho baseado no Programa" significa tanto
o Programa em si como quaisquer trabalhos derivados, de acordo com a
lei de direitos autorais: isto quer dizer um trabalho que contenha o
Programa ou parte dele, tanto originalmente ou com modificações, e/ou
tradução para outros idiomas. (Doravante o processo de tradução está
incluído sem limites no termo "modificação".) Cada licenciado é
mencionado como "você".

Atividades outras que a cópia, a distribuição e modificação não estão
cobertas por esta Licença; elas estão fora de seu escopo.  O ato de
executar o Programa não é restringido e o resultado do Programa é
coberto apenas se seu conteúdo contenha trabalhos baseados no Programa
(independentemente de terem sido gerados pela execução do
Programa). Se isso é verdadeiro depende do que o programa faz.

  1. Você pode copiar e distribuir cópias fiéis do código-fonte do
Programa da mesma forma que você o recebeu, usando qualquer meio,
deste que você conspícua e apropriadamente publique em cada cópia um
aviso de direitos autorais e uma declaração de inexistência de
garantias; mantenha intactas todos os avisos que se referem a esta
Licença e à ausência total de garantias; e forneça a outros
recebedores do Programa uma cópia desta Licença, junto com o Programa.

Você pode cobrar pelo ato físico de transferir uma cópia e pode,
opcionalmente, oferecer garantia em troca de pagamento.

  2. Você pode modificar sua cópia ou cópias do Programa, ou qualquer
parte dele, assim gerando um trabalho baseado no Programa, e copiar e
distribuir essas modificações ou trabalhos sob os termos da seção 1
acima, desde que você também se enquadre em todas estas condições:

    a) Você tem que fazer com que os arquivos modificados levem avisos
    proeminentes afirmando que você alterou os arquivos, incluindo a
    data de qualquer alteração.

    b) Você tem que fazer com que quaisquer trabalhos que você
    distribua ou publique, e que integralmente ou em partes contenham
    ou sejam derivados do Programa ou de suas partes, sejam
    licenciados, integralmente e sem custo algum para quaisquer
    terceiros, sob os termos desta Licença.

    c) Se qualquer programa modificado normalmente lê comandos
    interativamente quando executados, você tem que fazer com que,
    quando iniciado tal uso interativo da forma mais simples, seja
    impresso ou mostrado um anúncio de que não há qualquer garantia
    (ou então que você fornece a garantia) e que os usuários podem
    redistribuir o programa sob estas condições, ainda informando os
    usuários como consultar uma cópia desta Licença. (Exceção: se o
    Programa em si é interativo mas normalmente não imprime estes
    tipos de anúncios, seu trabalho baseado no Programa não precisa
    imprimir um anúncio.)

Estas exigências aplicam-se ao trabalho modificado como um todo. Se
seções identificáveis de tal trabalho não são derivadas do Programa, e
podem ser razoavelmente consideradas trabalhos independentes e
separados por si só, então esta Licença, e seus termos, não se aplicam
a estas seções quando você distribui-las como trabalhos em
separado. Mas quando você distribuir as mesmas seções como parte de um
todo que é trabalho baseado no Programa, a distribuição como um todo
tem que se enquadrar nos termos desta Licença, cujas permissões para
outros licenciados se estendem ao todo, portanto também para cada e
toda parte independente de quem a escreveu.

Desta forma, esta seção não tem a intenção de reclamar direitos os
contestar seus direitos sobre o trabalho escrito completamente por
você; ao invés disso, a intenção é a de exercitar o direito de
controlar a distribuição de trabalhos, derivados ou coletivos,
baseados no Programa.

Adicionalmente, a mera adição ao Programa de outro trabalho não
baseado no Programa (ou de trabalho baseado no Programa) em um volume
de armazenamento ou meio de distribuição não faz o outro trabalho
parte do escopo desta Licença.

  3. Você pode copiar e distribuir o Programa (ou trabalho baseado
nele, conforme descrito na Seção 2) em código-objeto ou em forma
executável sob os termos das Seções 1 e 2 acima, desde que você
faça um dos seguintes:

    a) O acompanhe com o código-fonte completo e em forma acessível
    por máquinas, que tem que ser distribuído sob os termos das Seções
    1 e 2 acima e em meio normalmente utilizado para o intercâmbio de
    software; ou,

    b) O acompanhe com uma oferta escrita, válida por pelo menos três
    anos, de fornecer a qualquer um, com um custo não superior ao
    custo de distribuição física do material, uma cópia do
    código-fonte completo e em forma acessível por máquinas, que tem
    que ser distribuído sob os termos das Seções 1 e 2 acima e em meio
    normalmente utilizado para o intercâmbio de software; ou,

    c) O acompanhe com a informação que você recebeu em relação à
    oferta de distribuição do código-fonte correspondente. (Esta
    alternativa é permitida somente em distribuição não comerciais, e
    apenas se você recebeu o programa em forma de código-objeto ou
    executável, com oferta de acordo com a Subseção b acima.)

O código-fonte de um trabalho corresponde à forma de trabalho
preferida para se fazer modificações. Para um trabalho em forma
executável, o código-fonte completo significa todo o código-fonte de
todos os módulos que ele contém, mais quaisquer arquivos de definição
de "interface", mais os "scripts" utilizados para se controlar a
compilação e a instalação do executável. Contudo, como exceção
especial, o código-fonte distribuído não precisa incluir qualquer
componente normalmente distribuído (tanto em forma original quanto
binária) com os maiores componentes (o compilador, o "kernel" etc.) do
sistema operacional sob o qual o executável funciona, a menos que o
componente em si acompanhe o executável.

Se a distribuição do executável ou código-objeto é feita através da
oferta de acesso a cópias de algum lugar, então ofertar o acesso
equivalente a cópia, do mesmo lugar, do código-fonte equivale à
distribuição do código-fonte, mesmo que terceiros não sejam compelidos
a copiar o código-fonte com o código-objeto.

  4. Você não pode copiar, modificar, sub-licenciar ou distribuir o
Programa, exceto de acordo com as condições expressas nesta
Licença. Qualquer outra tentativa de cópia, modificação,
sub-licenciamento ou distribuição do Programa não é valida, e
cancelará automaticamente os direitos que lhe foram fornecidos por
esta Licença. No entanto, terceiros que de você receberam cópias ou
direitos, fornecidos sob os termos desta Licença, não terão suas
licenças terminadas, desde que permaneçam em total concordância com
ela.

  5. Você não é obrigado a aceitar esta Licença já que não a
assinou. No entanto, nada mais o dará permissão para modificar ou
distribuir o Programa ou trabalhos derivados deste. Estas ações são
proibidas por lei, caso você não aceite esta Licença. Desta forma, ao
modificar ou distribuir o Programa (ou qualquer trabalho derivado do
Programa), você estará indicando sua total aceitação desta Licença
para fazê-los, e todos os seus termos e condições para copiar,
distribuir ou modificar o Programa, ou trabalhos baseados nele.

  6. Cada vez que você redistribuir o Programa (ou qualquer trabalho
baseado nele), os recebedores adquirirão automaticamente do
licenciador original uma licença para copiar, distribuir ou modificar
o Programa, sujeitos a estes termos e condições. Você não poderá impor
aos recebedores qualquer outra restrição ao exercício dos direitos
então adquiridos. Você não é responsável em garantir a concordância de
terceiros a esta Licença.

  7. Se, em conseqüência de decisões judiciais ou alegações de
infringimento de patentes ou quaisquer outras razões (não limitadas a
assuntos relacionados a patentes), condições forem impostas a você
(por ordem judicial, acordos ou outras formas) e que contradigam as
condições desta Licença, elas não o livram das condições desta
Licença. Se você não puder distribuir de forma a satisfazer
simultaneamente suas obrigações para com esta Licença e para com as
outras obrigações pertinentes, então como conseqüência você não poderá
distribuir o Programa. Por exemplo, se uma licença de patente não
permitirá a redistribuição, livre de "royalties", do Programa, por
todos aqueles que receberem cópias direta ou indiretamente de você,
então a única forma de você satisfazer a ela e a esta Licença seria a
de desistir completamente de distribuir o Programa.

Se qualquer parte desta seção for considerada inválida ou não
aplicável em qualquer circunstância particular, o restante da seção se
aplica, e a seção como um todo se aplica em outras circunstâncias.

O propósito desta seção não é o de induzi-lo a infringir quaisquer
patentes ou reivindicação de direitos de propriedade outros, ou a
contestar a validade de quaisquer dessas reivindicações; esta seção
tem como único propósito proteger a integridade dos sistemas de
distribuição de software livres, o que é implementado pela prática de
licenças públicas. Várias pessoas têm contribuído generosamente e em
grande escala para os software distribuídos usando este sistema, na
certeza de que sua aplicação é feita de forma consistente; fica a
critério do autor/doador decidir se ele ou ela está disposto a
distribuir software utilizando outro sistema, e um licenciado não pode
impor qualquer escolha.

Esta seção destina-se a tornar bastante claro o que se acredita ser
conseqüência do restante desta Licença.

  8. Se a distribuição e/ou uso do Programa são restringidos em certos
países por patentes ou direitos autorais, o detentor dos direitos
autorais original, e que colocou o Programa sob esta Licença, pode
incluir uma limitação geográfica de distribuição, excluindo aqueles
países de forma a tornar a distribuição permitida apenas naqueles ou
entre aqueles países então não excluídos. Nestes casos, esta Licença
incorpora a limitação como se a mesma constasse escrita nesta Licença.

  9. A Free Software Foundation pode publicar versões revisadas e/ou
novas da Licença Pública Geral de tempos em tempos. Estas novas
versões serão similares em espírito à versão atual, mas podem diferir
em detalhes que resolvem novos problemas ou situações.

A cada versão é dada um número distinto. Se o Programa especifica um
número de versão específico desta Licença que se aplica a ele e a
"qualquer nova versão", você tem a opção de aceitar os termos e
condições daquela versão ou de qualquer outra versão publicada pela
Free Software Foundation. Se o programa não especifica um número de
versão desta Licença, você pode escolher qualquer versão já publicada
pela Free Software Foundation.

  10. Se você pretende incorporar partes do Programa em outros
programas livres cujas condições de distribuição são diferentes,
escreva ao autor e solicite permissão. Para o software que a Free
Software Foundation detém direitos autorais, escreva à Free Software
Foundation; às vezes nós permitimos exceções a este caso. Nossa
decisão será guiada pelos dois objetivos de preservar a condição de
liberdade de todas as derivações do nosso software livre, e de
promover o compartilhamento e reutilização de software em aspectos
gerais.

			AUSÊNCIA DE GARANTIAS

  11. UMA VEZ QUE O PROGRAMA É LICENCIADO SEM ÔNUS, NÃO HÁ QUALQUER
GARANTIA PARA O PROGRAMA, NA EXTENSÃO PERMITIDA PELAS LEIS
APLICÁVEIS. EXCETO QUANDO EXPRESSADO DE FORMA ESCRITA, OS DETENTORES
DOS DIREITOS AUTORAIS E/OU TERCEIROS DISPONIBILIZAM O PROGRAMA "NO
ESTADO", SEM QUALQUER TIPO DE GARANTIAS, EXPRESSAS OU IMPLÍCITAS,
INCLUINDO, MAS NÃO LIMITADO A, AS GARANTIAS IMPLÍCITAS DE
COMERCIALIZAÇÃO E AS DE ADEQUAÇÃO A QUALQUER PROPÓSITO. O RISCO TOTAL
COM A QUALIDADE E DESEMPENHO DO PROGRAMA É SEU. SE O PROGRAMA SE
MOSTRAR DEFEITUOSO, VOCÊ ASSUME OS CUSTOS DE TODAS AS MANUTENÇÕES,
REPAROS E CORREÇÕES.

  12. EM NENHUMA OCASIÃO, A MENOS QUE EXIGIDO PELAS LEIS APLICÁVEIS OU
ACORDO ESCRITO, OS DETENTORES DOS DIREITOS AUTORAIS, OU QUALQUER OUTRA
PARTE QUE POSSA MODIFICAR E/OU REDISTRIBUIR O PROGRAMA CONFORME
PERMITIDO ACIMA, SERÃO RESPONSABILIZADOS POR VOCÊ POR DANOS, INCLUINDO
QUALQUER DANO EM GERAL, ESPECIAL, ACIDENTAL OU CONSEQÜENTE,
RESULTANTES DO USO OU INCAPACIDADE DE USO DO PROGRAMA (INCLUINDO, MAS
NÃO LIMITADO A, A PERDA DE DADOS OU DADOS TORNADOS INCORRETOS, OU
PERDAS SOFRIDAS POR VOCÊ OU POR OUTRAS PARTES, OU FALHAS DO PROGRAMA
AO OPERAR COM QUALQUER OUTRO PROGRAMA), MESMO QUE TAL DETENTOR OU
PARTE TENHAM SIDO AVISADOS DA POSSIBILIDADE DE TAIS DANOS.

		      FIM DOS TERMOS E CONDIÇÕES

	  Como Aplicar Estes Termos aos Seus Novos Programas

  Se você desenvolver um novo programa, e quer que ele seja utilizado
amplamente pelo público, a melhor forma de alcançar este objetivo é
torná-lo software livre que qualquer um pode redistribuir e alterar,
sob estes termos.

  Para isso, anexe os seguintes avisos ao programa. É mais seguro
anexá-los logo no início de cada arquivo-fonte para reforçarem mais
efetivamente a inexistência de garantias; e cada arquivo deve possuir
pelo menos a linha de "copyright" e uma indicação de onde o texto
completo se encontra.

    <uma linha que forneça o nome do programa e uma idéia do que ele faz.>
    Copyright (C) <ano>  <nome do autor>
   
    Este programa é software livre; você pode redistribuí-lo e/ou
    modificá-lo sob os termos da Licença Pública Geral GNU, conforme
    publicada pela Free Software Foundation; tanto a versão 2 da
    Licença como (a seu critério) qualquer versão mais nova.

    Este programa é distribuído na expectativa de ser útil, mas SEM
    QUALQUER GARANTIA; sem mesmo a garantia implícita de
    COMERCIALIZAÇÃO ou de ADEQUAÇÃO A QUALQUER PROPÓSITO EM
    PARTICULAR. Consulte a Licença Pública Geral GNU para obter mais
    detalhes.
 
    Você deve ter recebido uma cópia da Licença Pública Geral GNU
    junto com este programa; se não, escreva para a Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
    02111-1307, USA.

Inclua também informações sobre como contactá-lo eletronicamente e por
carta.

Se o programa é interativo, faça-o mostrar um aviso breve como este,
ao iniciar um modo interativo:

    Gnomovision versão 69, Copyright (C) ano nome do autor
    O Gnomovision não possui QUALQUER GARANTIA; para obter mais
    detalhes digite `show w'. Ele é software livre e você está
    convidado a redistribui-lo sob certas condições; digite `show c'
    para obter detalhes.

Os comandos hipotéticos `show w' e `show c' devem mostrar as partes
apropriadas da Licença Pública Geral. Claro, os comandos que você usar
podem ser ativados de outra forma que `show w' e `show c'; eles podem
até ser cliques do mouse ou itens de um menu -- o que melhor se
adequar ao programa.

Você também deve obter do seu empregador (se você trabalha como
programador) ou escola, se houver, uma "declaração de ausência de
direitos autorais" sobre o programa, se necessário. Aqui está um
exemplo; altere os nomes:

   Yoyodyne, Inc., aqui declara a ausência de quaisquer direitos
   autorais sobre o programa `Gnomovision' (que executa interpretações
   em compiladores) escrito por James Hacker.

   <assinatura de Ty Coon>, 1o. de abril de 1989
   Ty Con, Vice-presidente

Esta Licença Pública Geral não permite incorporar seu programa em
programas proprietários. Se seu programa é uma biblioteca de
sub-rotinas, você deve considerar mais útil permitir ligar aplicações
proprietárias com a biblioteca. Se isto é o que você deseja, use a
Licença Pública Geral de Bibliotecas GNU, ao invés desta Licença.
*******************************************************************************/

/*******************************************************************************
T E S T E   D A   C L A S S E
********************************************************************************
Para testar a classe de núcleo principal, apenas descomente as linhas abaixo.
*******************************************************************************/
/*
#Título do Teste
print("<h1>OSIRIS Core Test</h1>");
print("<pre>");
#Instância da Classe
$Osiris = new Osiris(true);
#Teste da Classe
$Osiris->Test();
print("</pre>");

$Osiris = new Osiris();
$Osiris->DB2XML("select cod_teste as 'Code', nome as 'Name', descricao as 'Description' from teste");
*/
?>
Return current item: Osiris Core