Skip to content
This repository
Browse code

DatabaseModel class refactoring done.

  • Loading branch information...
commit afdb37dd445dcc080142b0c4f9352a00c64ad429 1 parent 4444ea2
Raphael Araújo e Silva rkhaotix authored

Showing 1 changed file with 55 additions and 286 deletions. Show diff stats Hide diff stats

  1. +55 286 libpgmodeler/src/databasemodel.cpp
341 libpgmodeler/src/databasemodel.cpp
@@ -5329,38 +5329,35 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5329 5329 general_obj_cnt=this->getObjectCount();
5330 5330 gen_defs_count=0;
5331 5331
5332   - /* Tratandos os objetos os quais tem ids fixos são eles: Papel, Espaço de Tabela,
5333   - e Esquema. Estes precisam ser tratados separadamente no laço abaixo pois não
5334   - entram na ordenação de ids executada para os demais tipos de objetos. */
  5332 + /* Treating the objects which have fixed ids, they are: Paper, table space,
  5333 + and Schema. They need to be treated separately in the loop down because they do not
  5334 + enter in the id sorting performed for other types of objects. */
5335 5335 for(i=0; i < 3; i++)
5336 5336 {
5337   - //Obtém a lista de objetos do tipo
5338 5337 obj_list=getObjectList(aux_obj_types[i]);
5339 5338
5340   - /* Caso o tipo de definição seja SQL obtem o nome do atributo
5341   - do tipo do objeto nos esquema SQL */
5342 5339 if(def_type==SchemaParser::SQL_DEFINITION)
5343 5340 {
5344 5341 attrib=BaseObject::objs_schemas[aux_obj_types[i]];
5345 5342 attribs_aux[attrib]="";
5346 5343 }
5347 5344
5348   - //Obtém o início e o fim da lista para uma varredura
5349 5345 itr=obj_list->begin();
5350 5346 itr_end=obj_list->end();
5351 5347
5352 5348 while(itr!=itr_end)
5353 5349 {
5354   - //Obtém o objeto atual
5355 5350 object=(*itr);
5356 5351
  5352 + //The "public" schema does not have the SQL code definition generated
5357 5353 if(object->getObjectType()!=OBJ_SCHEMA ||
5358 5354 (object->getObjectType()==OBJ_SCHEMA &&
5359 5355 object->getName()!="public"))
5360 5356 {
5361   - //Gera o codigo e o concatena com os demais já gerados
  5357 + //Generates the code definition and concatenates to the others
5362 5358 attribs_aux[attrib]+=validateObjectDefinition(object, def_type);
5363   - //Dispara um sinal para sinalizar o progresso da geração do códgio
  5359 +
  5360 + //Increments the generated definition count and emits the signal
5364 5361 gen_defs_count++;
5365 5362 if(!signalsBlocked())
5366 5363 {
@@ -5375,19 +5372,11 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5375 5372 }
5376 5373 }
5377 5374
5378   - /* Armazena os próprio objeto de modelo de objetos pois o mesmo também precisa estar na
5379   - ordenação de objetos para ser criado na ordem correta quando o parser xml ler
5380   - a definição */
  5375 + //Includes the database model on the objects map permitting to create the code in a correct order
5381 5376 objects_map[this->getObjectId()]=this;
5382 5377 ids_objs.push_back(this->getObjectId());
5383 5378
5384   -
5385   - /* Armazenando os demais tipos de objetos no mapa de objetos para
5386   - serem ordenados pelos ids. */
5387   - /* Para definição XML todos os 16 tipos da lista 'tipos_objs' são tratados.
5388   - Para definição SQL são tratados apenas os 12 primeiros (tabelas, relacionamentos, visões e sequências)
5389   - são tratadas separadamente pois existe uma ordem específica em que elas precisam ser criadas e essa
5390   - ordem é definida na interação após a ordenação dos objetos */
  5379 + //Generating the definition for the other objects type
5391 5380 if(def_type==SchemaParser::XML_DEFINITION)
5392 5381 count=16;
5393 5382 else
@@ -5395,44 +5384,33 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5395 5384
5396 5385 for(i=0; i < count; i++)
5397 5386 {
5398   - /* Seleciona a lista de objetos para obter os identificadores e armazenar seus
5399   - elementos no mapa de objetos. No caso de definição SQL apenas os objetos
5400   - caixa de texto e relacionamento tabela-visão não são obtidos pois os mesmos
5401   - não possuem código SQL */
  5387 + //For SQL definition, only the textbox and base relationship does not has the code generated
5402 5388 if(def_type==SchemaParser::SQL_DEFINITION &&
5403 5389 (obj_types[i]==OBJ_TEXTBOX || obj_types[i]==BASE_RELATIONSHIP))
5404 5390 obj_list=NULL;
5405 5391 else
5406   - //Obtém a lista de objeto de acorodo com o tipo
5407 5392 obj_list=getObjectList(obj_types[i]);
5408 5393
5409 5394 if(obj_list)
5410 5395 {
5411   - //Obtém o início e o fim da lista para uma varredura
5412 5396 itr=obj_list->begin();
5413 5397 itr_end=obj_list->end();
5414 5398
5415 5399 while(itr!=itr_end)
5416 5400 {
5417   - //Obtém o objeto atual
5418 5401 object=(*itr);
5419   - //Armazena o objeto em si no mapa de objetos
5420 5402 objects_map[object->getObjectId()]=object;
5421   - //Armazena o id do objeto na lista de ids usada para referenciar os objetos no mapa
5422 5403 ids_objs.push_back(object->getObjectId());
5423 5404 itr++;
5424 5405 }
5425 5406 }
5426 5407 }
5427 5408
5428   - /* ** Trecho especial **:
5429   - Obtenção e armazenamento dos objetos especiais (os quais
5430   - referenciam colunas de tabelas adicionadas por relacionamentos)
5431   - no mapa de objetos e seus ids em um vetor auxiliar de ids 'vet_id_objs_tab'.
5432   - Para isso a lista de tabelas é varrida novamente e suas restrições e índices
5433   - são validados como especiais ou não. O vetor de ids é concatenado ao vetor de ids principal
5434   - antes de sua ordenação quando a definição é XML ou concatenado após a ordenação para def. SQL, desta
5435   - forma os objetos especiais são criados de forma correta em ambas as linguagens */
  5409 + /* Getting and storing the special objects (which reference columns of tables added for relationships)
  5410 + on the map of objects and their ids in an array of auxiliary ids 'ids_tab_objs'.
  5411 + For this list of tables is scanned again and its constraints and indexes are validated as special or not.
  5412 + The vector of ids is concatenated to the main vector of ids before his ordination when the definition is XML
  5413 + or concatenated after ordination to SQL definition, so the special objects are created correctly in both languages */
5436 5414 itr=tables.begin();
5437 5415 itr_end=tables.end();
5438 5416
@@ -5441,16 +5419,14 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5441 5419 table=dynamic_cast<Table *>(*itr);
5442 5420 itr++;
5443 5421
5444   - //Varre a lista de restrições da tabela
5445 5422 count=table->getConstraintCount();
5446 5423 for(i=0; i < count; i++)
5447 5424 {
5448 5425 constr=table->getConstraint(i);
5449 5426
5450   - /* Caso a restrição seja um objeto especial armazena o mesmo no mapa de objetos.
5451   - Idenpendente da configuração, chaves estrangeiras sempre serão descartadas nesta
5452   - iteração pois ao final do método as mesmas tem seu código SQL concatenado definição
5453   - do modelo */
  5427 + /* Case the constraint is a special object stores it on the objects map. Independently to the
  5428 + configuration, foreign keys are discarded in this iteration because on the end of the method
  5429 + they have the definition generated */
5454 5430 if((def_type==SchemaParser::XML_DEFINITION ||
5455 5431 (def_type==SchemaParser::SQL_DEFINITION &&
5456 5432 constr->getConstraintType()!=ConstraintType::foreign_key)) &&
@@ -5459,63 +5435,50 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5459 5435 ((constr->getConstraintType()!=ConstraintType::primary_key && constr->isReferRelationshipAddedColumn()) ||
5460 5436 (constr->getConstraintType()==ConstraintType::foreign_key))))
5461 5437 {
5462   - //Armazena o objeto em si no mapa de objetos
5463 5438 objects_map[constr->getObjectId()]=constr;
5464   - //Armazena o id do objeto na lista de ids usada para referenciar os objetos no mapa
5465 5439 ids_tab_objs.push_back(constr->getObjectId());
5466 5440 }
5467 5441 }
5468 5442
5469   - //Varre a lista de gatilhos da tabela
5470 5443 count=table->getTriggerCount();
5471 5444 for(i=0; i < count; i++)
5472 5445 {
5473 5446 trigger=table->getTrigger(i);
5474 5447
5475   - //Caso o gatilho seja um objeto especial armazena-o no mapa de objetos
5476 5448 if(trigger->isReferRelationshipAddedColumn())
5477 5449 {
5478   - //Armazena o objeto em si no mapa de objetos
5479 5450 objects_map[trigger->getObjectId()]=trigger;
5480   - //Armazena o id do objeto na lista de ids usada para referenciar os objetos no mapa
5481 5451 ids_tab_objs.push_back(trigger->getObjectId());
5482 5452 }
5483 5453 }
5484 5454
5485   - //Varre a lista de índices da tabela
5486 5455 count=table->getIndexCount();
5487 5456 for(i=0; i < count; i++)
5488 5457 {
5489 5458 index=table->getIndex(i);
5490 5459
5491   - //Caso o índice seja um objeto especial armazena-o no mapa de objetos
5492 5460 if(index->isReferRelationshipAddedColumn())
5493 5461 {
5494   - //Armazena o objeto em si no mapa de objetos
5495 5462 objects_map[index->getObjectId()]=index;
5496   - //Armazena o id do objeto na lista de ids usada para referenciar os objetos no mapa
5497 5463 ids_tab_objs.push_back(index->getObjectId());
5498 5464 }
5499 5465 }
5500 5466 }
5501 5467
5502   - /* Concatena o vetor de ids auxiliar (ids de objetos especiais) ao vetor de ids principal
5503   - antes da ordenação caso a definição seja XML */
5504 5468 if(def_type==SchemaParser::XML_DEFINITION)
5505 5469 ids_objs.insert(ids_objs.end(), ids_tab_objs.begin(), ids_tab_objs.end());
5506 5470
5507   - //Ordena o vetor de identificadores em ordem crescente
  5471 + //Sort the objects id vector to created the definition in a correct way
5508 5472 sort(ids_objs.begin(), ids_objs.end());
5509 5473
5510   - /* CASO ESPECIAL: Gerando a SQL de tabelas, visões, relacionamentos e sequencias de forma ordenada.
  5474 + /* SPECIAL CASE: Generating the SQL for tables, views, relationships and sequences
5511 5475
5512   - Esta geração é feita da seguinte forma:
5513   - 1) Com a lista de relacionamentos, gera o SQL de ambas as tabelas do relacionametno e logo em seguida a
5514   - SQL do relacionametno em si.
5515   - 2) Para as demais tabelas que não participaram de relacionamentos, gerar o SQL de cada uma.
5516   - 3) As sequencias devem ter seus SQL gerados após as tabelas restantes
5517   - 4) Visões devem ser as últimas a terem o SQL gerado para não terem referências a colunas e tabelas quebradas
5518   - */
  5476 + This generations is made in the following way:
  5477 + 1) Based on the relationship list, generates the SQL for the participant tables and after this the
  5478 + SQL for the relationship itself.
  5479 + 2) Generates the SQL for the other tables (that does not participates in relationships)
  5480 + 3) The sequences must have its code generated after the tables
  5481 + 4) View are the last objects that has the code generated avoiding table/column reference breaking */
5519 5482 if(def_type==SchemaParser::SQL_DEFINITION)
5520 5483 {
5521 5484 BaseObject *objs[3]={NULL, NULL, NULL};
@@ -5565,16 +5528,11 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5565 5528 }
5566 5529 }
5567 5530
5568   - /* Concatena o vetor de ids auxiliar (ids de objetos especiais) ao vetor de ids principal
5569   - após a ordenação caso a definição seja SQL */
5570 5531 if(def_type==SchemaParser::SQL_DEFINITION)
5571 5532 ids_objs.insert(ids_objs.end(), ids_tab_objs.begin(), ids_tab_objs.end());
5572 5533
5573 5534 attribs_aux[ParsersAttributes::SHELL_TYPES]="";
5574 5535
5575   - /* Caso a definição seja SQL e existam tipos definidos pelo usuário
5576   - faz a conversão dos parâmetros das funções usadas internamente
5577   - por estes */
5578 5536 if(def_type==SchemaParser::SQL_DEFINITION)
5579 5537 {
5580 5538 itr=types.begin();
@@ -5590,29 +5548,21 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5590 5548 }
5591 5549 }
5592 5550
5593   - //Varre a lista de ids de objetos para obtê-los do mapa de objetos
5594 5551 itr1=ids_objs.begin();
5595 5552 itr1_end=ids_objs.end();
5596 5553
5597 5554 attrib=ParsersAttributes::OBJECTS;
5598 5555 while(itr1!=itr1_end)
5599 5556 {
5600   - /* Obtém o objeto do mapa a partir do seu identificador
5601   - armazenado no iterador atual */
5602 5557 object=objects_map[(*itr1)];
5603   -
5604   - //Obtém o tipo do objeto
5605 5558 obj_type=object->getObjectType();
5606 5559 itr1++;
5607 5560
5608   - /* Caso seja um objeto tipo e a definição seja SQL armazena a
5609   - definição shell dos tipos os quais são declarados antes da criação
5610   - dos tipos definidos pelo usuário */
5611 5561 if(obj_type==OBJ_TYPE && def_type==SchemaParser::SQL_DEFINITION)
5612 5562 {
5613 5563 usr_type=dynamic_cast<Type *>(object);
5614 5564
5615   - //Obtendo a definição do tipo em forma de shell type
  5565 + //Generating the shell type declaration (only for base types)
5616 5566 if(usr_type->getConfiguration()==Type::BASE_TYPE)
5617 5567 attribs_aux[ParsersAttributes::SHELL_TYPES]+=usr_type->getCodeDefinition(def_type, true);
5618 5568 else
@@ -5631,10 +5581,7 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5631 5581 }
5632 5582 else
5633 5583 {
5634   - /* Desprezando as linguagens c e sql
5635   - pois as mesmas não precisam ser declaradas explicitamente poir serem built-in */
5636   - if(//tipo_def==ParserEsquema::DEFINICAO_SQL &&
5637   - (obj_type==OBJ_LANGUAGE &&
  5584 + if((obj_type==OBJ_LANGUAGE &&
5638 5585 (object->getName()==~LanguageType("c") ||
5639 5586 object->getName()==~LanguageType("sql") ||
5640 5587 object->getName()==~LanguageType("plpgsql"))))
@@ -5643,7 +5590,6 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5643 5590 attribs_aux[attrib]+=validateObjectDefinition(object, def_type);
5644 5591 }
5645 5592
5646   - //Dispara um sinal para sinalizar o progresso da geração do códgio
5647 5593 gen_defs_count++;
5648 5594 if(!signalsBlocked())
5649 5595 {
@@ -5665,7 +5611,7 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5665 5611 }
5666 5612 }
5667 5613
5668   - //Gerando a definição sql/xml das permissões
  5614 + //Gernerating the SQL/XML code for permissions
5669 5615 itr=permissions.begin();
5670 5616 itr_end=permissions.end();
5671 5617 attribs_aux[ParsersAttributes::PERMISSION]="";
@@ -5674,7 +5620,6 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5674 5620 {
5675 5621 attribs_aux[ParsersAttributes::PERMISSION]+=dynamic_cast<Permission *>(*itr)->getCodeDefinition(def_type);
5676 5622
5677   - //Dispara um sinal para sinalizar o progresso final da geração de código
5678 5623 gen_defs_count++;
5679 5624 if(!signalsBlocked())
5680 5625 {
@@ -5688,7 +5633,6 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5688 5633 itr++;
5689 5634 }
5690 5635
5691   - //Configura os atributos específicos do modelo de banco
5692 5636 attribs_aux[ParsersAttributes::MODEL_AUTHOR]=author;
5693 5637
5694 5638 if(def_type==SchemaParser::XML_DEFINITION)
@@ -5697,8 +5641,6 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5697 5641 }
5698 5642 else
5699 5643 {
5700   - /* Ao final da obtenção da definição SQL do modelo, faz a conversão inversa
5701   - dos parâmetros das funções usadas pelos tipos base */
5702 5644 count1=types.size();
5703 5645 for(i=0; i < count1; i++)
5704 5646 {
@@ -5715,8 +5657,6 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5715 5657 {
5716 5658 if(def_type==SchemaParser::SQL_DEFINITION)
5717 5659 {
5718   - /* Em caso de erro na geração da definição SQL do modelo, faz a conversão inversa
5719   - dos parâmetros das funções usadas pelos tipos base */
5720 5660 count1=types.size();
5721 5661 for(i=0; i < count1; i++)
5722 5662 {
@@ -5728,10 +5668,8 @@ QString DatabaseModel::getCodeDefinition(unsigned def_type, bool export_file)
5728 5668 throw Exception(e.getErrorMessage(), e.getErrorType(),__PRETTY_FUNCTION__,__FILE__,__LINE__, &e);
5729 5669 }
5730 5670
5731   - //Armazena o atributo que indica se a exportação é para arquivo ou não
5732 5671 attribs_aux[ParsersAttributes::EXPORT_TO_FILE]=(export_file ? "1" : "");
5733 5672
5734   - //Retorna a definição do modelo completa
5735 5673 return(SchemaParser::getCodeDefinition(ParsersAttributes::DB_MODEL, attribs_aux, def_type));
5736 5674 }
5737 5675
@@ -5742,7 +5680,6 @@ void DatabaseModel::saveModel(const QString &filename, unsigned def_type)
5742 5680
5743 5681 output.open(QFile::WriteOnly);
5744 5682
5745   - //Caso não consiga abrir o arquivo para gravação
5746 5683 if(!output.isOpen())
5747 5684 {
5748 5685 str_aux=QString(Exception::getErrorMessage(ERR_FILE_NOT_WRITTEN).arg(filename));
@@ -5765,10 +5702,9 @@ void DatabaseModel::saveModel(const QString &filename, unsigned def_type)
5765 5702
5766 5703 void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *> &deps, bool inc_indirect_deps)
5767 5704 {
5768   - //Caso o objeto esteja alocado e o mesmo ainda não exista na lista de dependências
  5705 + //Case the object is allocated and is not included in the dependecies list
5769 5706 if(object && std::find(deps.begin(), deps.end(), object)==deps.end())
5770 5707 {
5771   - //Adiciona o objeto na lista de dependências
5772 5708 deps.push_back(object);
5773 5709
5774 5710
@@ -5776,9 +5712,8 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
5776 5712 {
5777 5713 ObjectType obj_type=object->getObjectType();
5778 5714
5779   - /* Caso o objeto possua esquema, espaço de tabela e dono,
5780   - busca e inclui se necessário as dependências desses
5781   - objetos na lista */
  5715 + /* if the object has a schema, tablespace and owner applies the
  5716 + dependecy search in these objects */
5782 5717 if(object->getSchema() && inc_indirect_deps)
5783 5718 getObjectDependecies(object->getSchema(), deps, inc_indirect_deps);
5784 5719
@@ -5788,135 +5723,108 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
5788 5723 if(object->getOwner() && inc_indirect_deps)
5789 5724 getObjectDependecies(object->getOwner(), deps, inc_indirect_deps);
5790 5725
5791   - //** Obtendo as dependências de Classe de Operadores **
  5726 + //** Getting the dependecies for operator class **
5792 5727 if(obj_type==OBJ_OPCLASS)
5793 5728 {
5794 5729 OperatorClass *op_class=dynamic_cast<OperatorClass *>(object);
5795   -
5796   - /* Obtém a referência para o tipo de dado da classe, caso um ponteiro válido seja retornado
5797   - indica que o tipo de dado é um definido pelo usuário (classe Tipo) e que este precisa
5798   - também ter as dependências obtidas */
5799   - BaseObject *usr_type=getObjectPgSQLType(op_class->getDataType());
5800   - //obterObjeto(*classe_op->obterTipoDado(), OBJETO_TIPO);
  5730 + BaseObject *usr_type=getObjectPgSQLType(op_class->getDataType());
5801 5731
5802 5732 if(usr_type)
5803 5733 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5804 5734
5805   - //Caso haja uma família de operadores obtém as dependências dela também
5806 5735 if(op_class->getFamily())
5807 5736 getObjectDependecies(op_class->getFamily(), deps, inc_indirect_deps);
5808 5737 }
5809   - //** Obtendo as dependências de Domínios **
  5738 + //** Getting the dependecies for domain **
5810 5739 else if(obj_type==OBJ_DOMAIN)
5811 5740 {
5812   - /* Obtém a referência para o tipo de dado do domínio, caso um ponteiro válido seja retornado
5813   - indica que o tipo de dado é um definido pelo usuário (classe Tipo) e que este precisa
5814   - também ter as dependências obtidas */
5815 5741 BaseObject *usr_type=getObjectPgSQLType(dynamic_cast<Domain *>(object)->getType());
5816   - //obterObjeto(*dynamic_cast<Dominio *>(objeto)->obterTipo(), OBJETO_TIPO);
5817 5742
5818 5743 if(usr_type)
5819 5744 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5820 5745 }
5821   - //** Obtendo as dependências de Conversões de Codificação **
  5746 + //** Getting the dependecies for conversion **
5822 5747 else if(obj_type==OBJ_CONVERSION)
5823 5748 {
5824   - //Obtém as dependências da função de conversão que define a conversão de codificação
5825 5749 Function *func=dynamic_cast<Conversion *>(object)->getConversionFunction();
5826 5750 getObjectDependecies(func, deps, inc_indirect_deps);
5827 5751 }
5828   - //** Obtendo as dependências de Conversões de Tipo **
  5752 + //** Getting the dependecies for cast **
5829 5753 else if(obj_type==OBJ_CAST)
5830 5754 {
5831 5755 Cast *cast=dynamic_cast<Cast *>(object);
5832 5756 BaseObject *usr_type=NULL;
5833 5757
5834   - //Obtém as dependências dos tipos usados na conversão de tipo
5835 5758 for(unsigned i=Cast::SRC_TYPE; i <= Cast::DST_TYPE; i++)
5836 5759 {
5837 5760 usr_type=getObjectPgSQLType(cast->getDataType(i));
5838   - //obterObjeto(*conv->obterTipoDado(i), OBJETO_TIPO);
5839 5761
5840 5762 if(usr_type)
5841 5763 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5842 5764 }
5843 5765
5844   - //Obtém as dependências da função de conversão que define a conversão de tipo
5845 5766 getObjectDependecies(cast->getCastFunction(), deps, inc_indirect_deps);
5846 5767 }
5847   - //** Obtendo as dependências de Funções **
  5768 + //** Getting the dependecies for function **
5848 5769 else if(obj_type==OBJ_FUNCTION)
5849 5770 {
5850 5771 Function *func=dynamic_cast<Function *>(object);
5851 5772 BaseObject *usr_type=getObjectPgSQLType(func->getReturnType());
5852   - //obterObjeto(*func->obterTipoRetorno(), OBJETO_TIPO);
5853 5773 unsigned count, i;
5854 5774
5855   - //Caso a linguagem da função não seja C ou SQL obtém as dependências da mesma
5856 5775 if(func->getLanguage()->getName()!=~LanguageType("c") &&
5857 5776 func->getLanguage()->getName()!=~LanguageType("sql"))
5858 5777 getObjectDependecies(func->getLanguage(), deps, inc_indirect_deps);
5859 5778
5860   - //Obtém as dependências do tipo de retorno caso o mesmo seja um tipo definido pelo usuário
5861 5779 if(usr_type)
5862 5780 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5863 5781
5864   - //Obtém as dependências dos tipos dos parâmetros
5865 5782 count=func->getParameterCount();
5866 5783 for(i=0; i < count; i++)
5867 5784 {
5868 5785 usr_type=getObjectPgSQLType(func->getParameter(i).getType());
5869   - //obterObjeto(*func->obterParametro(i).obterTipo(), OBJETO_TIPO);
5870 5786
5871 5787 if(usr_type)
5872 5788 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5873 5789 }
5874 5790
5875   - //Obtém as dependências dos elementos da tabela de retorno
5876 5791 count=func->getReturnedTableColumnCount();
5877 5792 for(i=0; i < count; i++)
5878 5793 {
5879 5794 usr_type=getObjectPgSQLType(func->getReturnedTableColumn(i).getType());
5880   - //obterObjeto(*func->obterTipoRetTabela(i).obterTipo(), OBJETO_TIPO);
5881 5795
5882 5796 if(usr_type)
5883 5797 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5884 5798 }
5885 5799 }
5886   - //** Obtendo as dependências de Funções de Agregação **
  5800 + //** Getting the dependecies for aggregate **
5887 5801 else if(obj_type==OBJ_AGGREGATE)
5888 5802 {
5889 5803 Aggregate *aggreg=dynamic_cast<Aggregate *>(object);
5890 5804 BaseObject *usr_type=NULL;
5891 5805 unsigned count, i;
5892 5806
5893   - //Obtém as dependências das funções que definem a função de agregação
5894 5807 for(i=Aggregate::FINAL_FUNC; i <= Aggregate::TRANSITION_FUNC; i++)
5895 5808 getObjectDependecies(aggreg->getFunction(i), deps, inc_indirect_deps);
5896 5809
5897   - //Obtém a dependência do tipo de estado da função de agregação
5898 5810 usr_type=getObjectPgSQLType(aggreg->getStateType());
5899   - //obterObjeto(*func->obterTipoEstado(), OBJETO_TIPO);
5900 5811
5901 5812 if(usr_type)
5902 5813 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5903 5814
5904   - //Obtém as dependências do operador de ordenação caso este esteja alocado
5905 5815 if(aggreg->getSortOperator())
5906 5816 getObjectDependecies(aggreg->getSortOperator(), deps, inc_indirect_deps);
5907 5817
5908   - //Obtém as dependências dos tipos de dados usados na função de agregação
5909 5818 count=aggreg->getDataTypeCount();
5910 5819 for(i=0; i < count; i++)
5911 5820 {
5912 5821 usr_type=getObjectPgSQLType(aggreg->getDataType(i));
5913   - //obterObjeto(*func->obterTipoDado(i), OBJETO_TIPO);
5914 5822
5915 5823 if(usr_type)
5916 5824 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5917 5825 }
5918 5826 }
5919   - //** Obtendo as dependências de Linguagens **
  5827 + //** Getting the dependecies for language **
5920 5828 else if(obj_type==OBJ_LANGUAGE)
5921 5829 {
5922 5830 Language *lang=dynamic_cast<Language *>(object);
@@ -5927,45 +5835,40 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
5927 5835 getObjectDependecies(lang->getFunction(i), deps, inc_indirect_deps);
5928 5836 }
5929 5837 }
5930   - //** Obtendo as dependências de Operadores **
  5838 + //** Getting the dependecies for operator **
5931 5839 else if(obj_type==OBJ_OPERATOR)
5932 5840 {
5933 5841 Operator *oper=dynamic_cast<Operator *>(object);
5934 5842 BaseObject *usr_type=NULL;
5935 5843 unsigned i;
5936 5844
5937   - //Obtém as dependências das funções usadas pelo operador
5938 5845 for(i=Operator::FUNC_OPERATOR; i <= Operator::FUNC_RESTRICTION; i++)
5939 5846 {
5940 5847 if(oper->getFunction(i))
5941 5848 getObjectDependecies(oper->getFunction(i), deps, inc_indirect_deps);
5942 5849 }
5943 5850
5944   - //Obtém as dependências dos tipos dos argumentos do operador
5945 5851 for(i=Operator::LEFT_ARG; i <= Operator::RIGHT_ARG; i++)
5946 5852 {
5947 5853 usr_type=getObjectPgSQLType(oper->getArgumentType(i));
5948   - //obterObjeto(*oper->obterTipoDadoArgumento(i), OBJETO_TIPO);
5949 5854
5950 5855 if(usr_type)
5951 5856 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5952 5857 }
5953 5858
5954   - //Obtém as dependências dos operadores auxiliares
5955 5859 for(i=Operator::OPER_COMMUTATOR; i <= Operator::OPER_GREATER; i++)
5956 5860 {
5957 5861 if(oper->getOperator(i))
5958 5862 getObjectDependecies(oper->getOperator(i), deps, inc_indirect_deps);
5959 5863 }
5960 5864 }
5961   - //** Obtendo as dependências de Papéis **
  5865 + //** Getting the dependecies for role **
5962 5866 else if(obj_type==OBJ_ROLE)
5963 5867 {
5964 5868 Role *role=dynamic_cast<Role *>(object);
5965 5869 unsigned i, i1, count,
5966 5870 role_types[3]={ Role::REF_ROLE, Role::MEMBER_ROLE, Role::ADMIN_ROLE };
5967 5871
5968   - //Obtém as dependências dos papéis membros, papéis admins e papéis referenciados
5969 5872 for(i=0; i < 3; i++)
5970 5873 {
5971 5874 count=role->getRoleCount(role_types[i]);
@@ -5973,7 +5876,7 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
5973 5876 getObjectDependecies(role->getRole(role_types[i], i1), deps, inc_indirect_deps);
5974 5877 }
5975 5878 }
5976   - //** Obtendo as dependências de Relacionamentos **
  5879 + //** Getting the dependecies for relationships **
5977 5880 else if(obj_type==OBJ_RELATIONSHIP)
5978 5881 {
5979 5882 Relationship *rel=dynamic_cast<Relationship *>(object);
@@ -5981,41 +5884,35 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
5981 5884 Constraint *constr=NULL;
5982 5885 unsigned i, count;
5983 5886
5984   - //Obtém as dependências das tabelas referenciadas pelo relacionamento
5985 5887 getObjectDependecies(rel->getTable(Relationship::SRC_TABLE), deps, inc_indirect_deps);
5986 5888 getObjectDependecies(rel->getTable(Relationship::DST_TABLE), deps, inc_indirect_deps);
5987 5889
5988   - //Obtém as dependências dos tipos usados pelos atributos do relacionamento
5989 5890 count=rel->getAttributeCount();
5990 5891 for(i=0; i < count; i++)
5991 5892 {
5992 5893 usr_type=getObjectPgSQLType(rel->getAttribute(i)->getType());
5993   - //obterObjeto(*rel->obterAtributo(i)->obterTipo(), OBJETO_TIPO);
5994 5894
5995 5895 if(usr_type)
5996 5896 getObjectDependecies(usr_type, deps, inc_indirect_deps);
5997 5897 }
5998 5898
5999   - //Obtém as dependências das restrições (somente chave estrangeira) do relacionamento
6000 5899 count=rel->getConstraintCount();
6001 5900 for(i=0; i < count; i++)
6002 5901 {
6003 5902 constr=dynamic_cast<Constraint *>(rel->getConstraint(i));
6004   - if(constr->getConstraintType()==ConstraintType::foreign_key)
6005   - getObjectDependecies(constr->getReferencedTable(), deps, inc_indirect_deps);
6006 5903
6007 5904 if(constr->getTablespace())
6008 5905 getObjectDependecies(constr->getTablespace(), deps, inc_indirect_deps);
6009 5906 }
6010 5907 }
6011   - //** Obtendo as dependências de Sequências **
  5908 + //** Getting the dependecies for sequence **
6012 5909 else if(obj_type==OBJ_SEQUENCE)
6013 5910 {
6014 5911 Sequence *seq=dynamic_cast<Sequence *>(object);
6015 5912 if(seq->getOwnerColumn())
6016 5913 getObjectDependecies(seq->getOwnerColumn()->getParentTable(), deps, inc_indirect_deps);
6017 5914 }
6018   - //** Obtendo as dependências de Tabelas **
  5915 + //** Getting the dependecies for table **
6019 5916 else if(obj_type==OBJ_TABLE)
6020 5917 {
6021 5918 Table *tab=dynamic_cast<Table *>(object);
@@ -6026,19 +5923,16 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
6026 5923 Column *col=NULL;
6027 5924 unsigned count, count1, i, i1;
6028 5925
6029   - //Obtém as dependências dos tipos das colunas não incluídas por relacionamento
6030 5926 count=tab->getColumnCount();
6031 5927 for(i=0; i < count; i++)
6032 5928 {
6033 5929 col=tab->getColumn(i);
6034 5930 usr_type=getObjectPgSQLType(col->getType());
6035   - //obterObjeto(*col->obterTipo(), OBJETO_TIPO);
6036 5931
6037 5932 if(!col->isAddedByLinking() && usr_type)
6038 5933 getObjectDependecies(usr_type, deps, inc_indirect_deps);
6039 5934 }
6040 5935
6041   - //Obtém as dependências das restrições não incluídas por relacionamento
6042 5936 count=tab->getConstraintCount();
6043 5937 for(i=0; i < count; i++)
6044 5938 {
@@ -6052,7 +5946,6 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
6052 5946 getObjectDependecies(constr->getTablespace(), deps, inc_indirect_deps);
6053 5947 }
6054 5948
6055   - //Obtém as dependências das tabelas referenciadas nos gatilhos e as funções
6056 5949 count=tab->getTriggerCount();
6057 5950 for(i=0; i < count; i++)
6058 5951 {
@@ -6062,13 +5955,8 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
6062 5955
6063 5956 if(trig->getFunction())
6064 5957 getObjectDependecies(trig->getFunction(), deps, inc_indirect_deps);
6065   -
6066   - //qtd1=gat->obterNumColunas();
6067   - //for(i1=0; i1 < qtd1; i1++)
6068   - //obterDependenciasObjeto(gat->obterColuna(i1), vet_deps, inc_dep_indiretas);
6069 5958 }
6070 5959
6071   - //Obtém as dependências das colunas ou classe de operadores usados nos elementos do índices
6072 5960 count=tab->getIndexCount();
6073 5961 for(i=0; i < count; i++)
6074 5962 {
@@ -6082,7 +5970,6 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
6082 5970 else if(index->getElement(i1).getColumn())
6083 5971 {
6084 5972 usr_type=getObjectPgSQLType(index->getElement(i1).getColumn()->getType());
6085   - //obterObjeto(*ind->obterElemento(i1).obterColuna()->obterTipo(), OBJETO_TIPO);
6086 5973
6087 5974 if(usr_type)
6088 5975 getObjectDependecies(usr_type, deps, inc_indirect_deps);
@@ -6090,49 +5977,41 @@ void DatabaseModel::getObjectDependecies(BaseObject *object, vector<BaseObject *
6090 5977 }
6091 5978 }
6092 5979 }
6093   - //** Obtendo as dependências de Tipos definidos pelo usuário **
  5980 + //** Getting the dependecies for user defined type **
6094 5981 else if(obj_type==OBJ_TYPE)
6095 5982 {
6096 5983 Type *usr_type=dynamic_cast<Type *>(object);
6097 5984 BaseObject *aux_type=NULL;
6098 5985 unsigned count, i;
6099 5986
6100   - //Caso o tipo de usuário seja tipo base
6101 5987 if(usr_type->getConfiguration()==Type::BASE_TYPE)
6102 5988 {
6103   - //Obtém as dependências do tipo de cópia
6104 5989 aux_type=getObjectPgSQLType(usr_type->getLikeType());
6105   - //obterObjeto(*tipo_usr->obterTipoCopia(), OBJETO_TIPO);
6106 5990
6107 5991 if(aux_type)
6108 5992 getObjectDependecies(aux_type, deps, inc_indirect_deps);
6109 5993
6110   - //Obtém as dependências das funções usadas pelo tipo
6111 5994 for(i=Type::INPUT_FUNC; i <= Type::ANALYZE_FUNC; i++)
6112 5995 getObjectDependecies(usr_type->getFunction(i), deps, inc_indirect_deps);
6113 5996 }
6114   - //Caso seja um tipo composto
6115 5997 else if(usr_type->getConfiguration()==Type::COMPOSITE_TYPE)
6116 5998 {
6117   - //Obtém as dependências dos tipos dos atributos
6118 5999 count=usr_type->getAttributeCount();
6119 6000 for(i=0; i < count; i++)
6120 6001 {
6121 6002 aux_type=getObjectPgSQLType(usr_type->getAttribute(i).getType());
6122   - //obterObjeto(*tipo_usr->obterAtributo(i).obterTipo(), OBJETO_TIPO);
6123 6003
6124 6004 if(aux_type)
6125 6005 getObjectDependecies(aux_type, deps, inc_indirect_deps);
6126 6006 }
6127 6007 }
6128 6008 }
6129   - //** Obtendo as dependências de Visões **
  6009 + //** Getting the dependecies for view **
6130 6010 else if(obj_type==OBJ_VIEW)
6131 6011 {
6132 6012 View *view=dynamic_cast<View *>(object);
6133 6013 unsigned i, count;
6134 6014
6135   - //Obtém as dependências das tabelas referenciadas pela visão
6136 6015 count=view->getReferenceCount();
6137 6016 for(i=0; i < count; i++)
6138 6017 {
@@ -6164,9 +6043,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6164 6043 vector<BaseObject *>::iterator itr, itr_end;
6165 6044 unsigned i, count;
6166 6045
6167   - /* Vericando se existe algum relacionamento (tabela-tabela)
6168   - o qual um dos objetos participantes é a tabela
6169   - do parâmetro */
6170 6046 itr=relationships.begin();
6171 6047 itr_end=relationships.end();
6172 6048
@@ -6182,8 +6058,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6182 6058 itr++;
6183 6059 }
6184 6060
6185   - /* Vericando se existe alguma sequência a qual referencia
6186   - a tabela do parâmetro */
6187 6061 itr=sequences.begin();
6188 6062 itr_end=sequences.end();
6189 6063
@@ -6200,10 +6074,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6200 6074 itr++;
6201 6075 }
6202 6076
6203   - /* Vericando se existe alguma tabela cuja uma tabela cópia é
6204   - a própria tabela a ser excluída, verifica também se as
6205   - restrições das tabelas, especificamente, as chaves estrangeiras
6206   - estão referenciado a tabela */
6207 6077 itr=tables.begin();
6208 6078 itr_end=tables.end();
6209 6079
@@ -6211,7 +6081,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6211 6081 {
6212 6082 tab=dynamic_cast<Table *>(*itr);
6213 6083
6214   - //Verificando as restrições
6215 6084 count=tab->getConstraintCount();
6216 6085 for(i=0; i < count&& (!exclusion_mode || (exclusion_mode && !refer)); i++)
6217 6086 {
@@ -6224,7 +6093,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6224 6093 }
6225 6094 }
6226 6095
6227   - //Verificando os gatilhos
6228 6096 count=tab->getTriggerCount();
6229 6097 for(i=0; i < count && (!exclusion_mode || (exclusion_mode && !refer)); i++)
6230 6098 {
@@ -6239,8 +6107,7 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6239 6107 itr++;
6240 6108 }
6241 6109
6242   - /* Vericando se existe algum relacionamento (tabela-visao)
6243   - o qual um dos objetos participantes é a tabela */
  6110 +
6244 6111 itr=base_relationships.begin();
6245 6112 itr_end=base_relationships.end();
6246 6113
@@ -6277,11 +6144,8 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6277 6144 Type *type=NULL;
6278 6145 Language *lang=NULL;
6279 6146
6280   - /* Varre todas as listas de objetos os quais podem
6281   - referenciar direta ou indiretamente uma função */
6282 6147 for(i=0; i < 7 && (!exclusion_mode || (exclusion_mode && !refer)); i++)
6283 6148 {
6284   - //Obtém uma lista
6285 6149 obj_list=getObjectList(obj_types[i]);
6286 6150 itr=obj_list->begin();
6287 6151 itr_end=obj_list->end();
@@ -6290,7 +6154,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6290 6154 {
6291 6155 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6292 6156 {
6293   - //Verifica se o objeto não referencia o papel
6294 6157 if(dynamic_cast<Cast *>(*itr)->getCastFunction()==func)
6295 6158 {
6296 6159 refer=true;
@@ -6303,7 +6166,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6303 6166 {
6304 6167 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6305 6168 {
6306   - //Verifica se o objeto não referencia o papel
6307 6169 if(dynamic_cast<Conversion *>(*itr)->getConversionFunction()==func)
6308 6170 {
6309 6171 refer=true;
@@ -6317,7 +6179,7 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6317 6179 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6318 6180 {
6319 6181 aggreg=dynamic_cast<Aggregate *>(*itr);
6320   - //Verifica se o objeto não referencia o papel
  6182 +
6321 6183 if(aggreg->getFunction(Aggregate::FINAL_FUNC)==func ||
6322 6184 aggreg->getFunction(Aggregate::TRANSITION_FUNC)==func)
6323 6185 {
@@ -6331,10 +6193,8 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6331 6193 {
6332 6194 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6333 6195 {
6334   - //Obtém a referência ao objeto
6335 6196 oper=dynamic_cast<Operator *>(*itr);
6336 6197
6337   - //Verifica se o objeto não referencia o papel
6338 6198 if(oper->getFunction(Operator::FUNC_OPERATOR)==func ||
6339 6199 oper->getFunction(Operator::FUNC_JOIN)==func ||
6340 6200 oper->getFunction(Operator::FUNC_RESTRICTION)==func)
@@ -6349,14 +6209,14 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6349 6209 {
6350 6210 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6351 6211 {
6352   - //Obtém a referência ao objeto
6353 6212 tab=dynamic_cast<Table *>(*itr);
6354 6213 itr++;
6355 6214 count=tab->getTriggerCount();
  6215 +
6356 6216 for(i1=0; i1 < count && (!exclusion_mode || (exclusion_mode && !refer)); i1++)
6357 6217 {
6358 6218 trig=tab->getTrigger(i1);
6359   - //Verifica se o gatilho não referencia a função
  6219 +
6360 6220 if(trig->getFunction()==func)
6361 6221 {
6362 6222 refer=true;
@@ -6369,13 +6229,11 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6369 6229 {
6370 6230 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6371 6231 {
6372   - //Obtém a referência ao objeto
6373 6232 type=dynamic_cast<Type *>(*itr);
6374 6233 itr++;
6375 6234
6376 6235 for(i1=Type::INPUT_FUNC; i1 <= Type::ANALYZE_FUNC && (!exclusion_mode || (exclusion_mode && !refer)); i1++)
6377 6236 {
6378   - //Verifica se o tipo não referencia a função
6379 6237 if(type->getFunction(i1)==func)
6380 6238 {
6381 6239 refer=true;
@@ -6388,10 +6246,9 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6388 6246 {
6389 6247 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6390 6248 {
6391   - //Obtém a referência ao objeto
6392 6249 lang=dynamic_cast<Language *>(*itr);
6393 6250 itr++;
6394   - //Verifica se a função a ser removida é uma função handler ou validator da linguagem
  6251 +
6395 6252 if(lang->getFunction(Language::HANDLER_FUNC)==func ||
6396 6253 lang->getFunction(Language::VALIDATOR_FUNC)==func ||
6397 6254 lang->getFunction(Language::INLINE_FUNC)==func)
@@ -6414,19 +6271,14 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6414 6271 OBJ_TYPE, OBJ_OPFAMILY, OBJ_OPCLASS};
6415 6272 unsigned i;
6416 6273
6417   - /* Varre todas as listas de objetos os quais pode pertencer a
6418   - um esquema e verifica se o mesmos não estão referenciando
6419   - o esquema a ser removido */
6420 6274 for(i=0; i < 11 && (!exclusion_mode || (exclusion_mode && !refer)); i++)
6421 6275 {
6422   - //Obtém uma lista
6423 6276 obj_list=getObjectList(obj_types[i]);
6424 6277 itr=obj_list->begin();
6425 6278 itr_end=obj_list->end();
6426 6279
6427 6280 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6428 6281 {
6429   - //Verifica se o objeto não referencia o esquema
6430 6282 if((*itr)->getSchema()==object)
6431 6283 {
6432 6284 refer=true;
@@ -6457,10 +6309,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6457 6309 Type *type=NULL;
6458 6310 void *ptr_pgsqltype=NULL;
6459 6311
6460   - /* Devido a particuladade de se atribuir ponteiros de objetos como tipos base do pgsql (ver TipoPgSQL)
6461   - é necessário fazer um dynamic_cast para a classe correta do 'objeto'. Caso o dynamic_cast não seja
6462   - feita, mesmo que o objeto seja um tipopgsql válido o mesmo não será localizado na lista de tipos
6463   - base do pgsql. */
6464 6312 switch(obj_type)
6465 6313 {
6466 6314 case OBJ_TYPE: ptr_pgsqltype=dynamic_cast<Type*>(object); break;
@@ -6469,31 +6317,24 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6469 6317 default: ptr_pgsqltype=dynamic_cast<Table*>(object); break;
6470 6318 }
6471 6319
6472   - /* Varre todas as listas de objetos os quais podem
6473   - referenciar direta ou indiretamente um tipo definido
6474   - pelo usuário */
6475 6320 for(i=0; i < 8 && (!exclusion_mode || (exclusion_mode && !refer)); i++)
6476 6321 {
6477   - //Obtém uma lista
6478 6322 obj_list=getObjectList(obj_types[i]);
6479 6323 itr=obj_list->begin();
6480 6324 itr_end=obj_list->end();
6481 6325
6482 6326 if(obj_types[i]==OBJ_TABLE)
6483 6327 {
6484   - //Verifica se as colunas das tabelas não referenciam o tipo
6485 6328 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6486 6329 {
6487   - //Obtém a tabela
6488 6330 tab=dynamic_cast<Table *>(*itr);
6489 6331 itr++;
6490 6332
6491   - //Varre a lista de colunas da tabela
6492 6333 count=tab->getColumnCount();
6493 6334 for(i1=0; i1 < count && (!exclusion_mode || (exclusion_mode && !refer)); i1++)
6494 6335 {
6495 6336 col=tab->getColumn(i1);
6496   - //Verifica se o tipo da coluna é o próprio tipo a ser excluído
  6337 +
6497 6338 if(col->getType()==object)
6498 6339 {
6499 6340 refer=true;
@@ -6504,15 +6345,11 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6504 6345 }
6505 6346 else if(obj_types[i]==OBJ_OPCLASS)
6506 6347 {
6507   - /* Varre a lista de classe operadores e verifica se algum
6508   - objeto referencia o tipo a ser excluído */
6509 6348 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6510 6349 {
6511   - //Obtém a referência ao objeto
6512 6350 op_class=dynamic_cast<OperatorClass *>(*itr);
6513 6351 itr++;
6514 6352
6515   - //Verifica se o tipo de dado da classe é o próprio tipo a ser removido
6516 6353 if(op_class->getDataType()==ptr_pgsqltype)
6517 6354 {
6518 6355 refer=true;
@@ -6522,15 +6359,11 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6522 6359 }
6523 6360 else if(obj_types[i]==OBJ_DOMAIN)
6524 6361 {
6525   - /* Varre a lista de domínios e verifica se algum
6526   - objeto referencia o tipo a ser excluído */
6527 6362 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6528 6363 {
6529   - //Obtém a referência ao objeto
6530 6364 dom=dynamic_cast<Domain *>(*itr);
6531 6365 itr++;
6532 6366
6533   - //Verifica se o tipo de dado do dominio é o próprio tipo a ser removido
6534 6367 if(dom->getType()==ptr_pgsqltype)
6535 6368 {
6536 6369 refer=true;
@@ -6540,11 +6373,8 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6540 6373 }
6541 6374 else if(obj_types[i]==OBJ_TYPE)
6542 6375 {
6543   - /* Varre a lista de tipo definidos pelo usuário e verifica se algum
6544   - objeto referencia o tipo a ser excluído */
6545 6376 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6546 6377 {
6547   - //Obtém a referência ao objeto
6548 6378 type=dynamic_cast<Type *>(*itr);
6549 6379 itr++;
6550 6380
@@ -6559,16 +6389,11 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6559 6389 }
6560 6390 else if(obj_types[i]==OBJ_AGGREGATE)
6561 6391 {
6562   - /* Varre a lista de funções agregadas e verifica se algum
6563   - objeto referencia o tipo a ser excluído */
6564 6392 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6565 6393 {
6566   - //Obtém a referência ao objeto
6567 6394 aggreg=dynamic_cast<Aggregate *>(*itr);
6568 6395 itr++;
6569 6396
6570   - /* Verifica se os tipos de dados da função agregada referenciam
6571   - tipo a ser removido */
6572 6397 count=aggreg->getDataTypeCount();
6573 6398 for(i1=0; i1 < count && (!exclusion_mode || (exclusion_mode && !refer)); i1++)
6574 6399 {
@@ -6582,16 +6407,11 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6582 6407 }
6583 6408 else if(obj_types[i]==OBJ_FUNCTION)
6584 6409 {
6585   - /* Varre a lista de funções e verifica se algum
6586   - objeto (parâmetros e tipo de retorno) referencia
6587   - o tipo a ser excluído */
6588 6410 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6589 6411 {
6590   - //Obtém a referência ao objeto
6591 6412 func=dynamic_cast<Function *>(*itr);
6592 6413 itr++;
6593 6414
6594   - //Verifica se o tipo de retorno é o próprio tipo a ser removido
6595 6415 if(func->getReturnType()==ptr_pgsqltype)
6596 6416 {
6597 6417 refer=true;
@@ -6599,8 +6419,6 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6599 6419 }
6600 6420 else
6601 6421 {
6602   - /* Verifica se os tipos de dados dos parâmetros da função
6603   - referenciam tipo a ser removido */
6604 6422 count=func->getParameterCount();
6605 6423 for(i1=0; i1 < count && (!exclusion_mode || (exclusion_mode && !refer)); i1++)
6606 6424 {
@@ -6615,15 +6433,11 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6615 6433 }
6616 6434 else if(obj_types[i]==OBJ_OPERATOR)
6617 6435 {
6618   - /* Varre a lista de operadores e verifica se algum
6619   - objeto referencia o tipo a ser excluído */
6620 6436 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6621 6437 {
6622   - //Obtém a referência ao objeto
6623 6438 oper=dynamic_cast<Operator *>(*itr);
6624 6439 itr++;
6625 6440
6626   - //Verifica se um dos argumentos do operador é o próprio tipo a ser removido
6627 6441 if(oper->getArgumentType(Operator::LEFT_ARG)==ptr_pgsqltype ||
6628 6442 oper->getArgumentType(Operator::RIGHT_ARG)==ptr_pgsqltype)
6629 6443 {
@@ -6636,11 +6450,9 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6636 6450 {
6637 6451 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6638 6452 {
6639   - //Obtém a referência ao objeto
6640 6453 cast=dynamic_cast<Cast *>(*itr);
6641 6454 itr++;
6642 6455
6643   - //Verifica se o objeto não referencia o tipo
6644 6456 if(cast->getDataType(Cast::SRC_TYPE)==ptr_pgsqltype ||
6645 6457 cast->getDataType(Cast::DST_TYPE)==ptr_pgsqltype)
6646 6458 {
@@ -6666,25 +6478,19 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6666 6478 Role *role=dynamic_cast<Role *>(object);
6667 6479 unsigned role_types[3]={Role::REF_ROLE, Role::MEMBER_ROLE, Role::ADMIN_ROLE};
6668 6480
6669   - /* Caso especial: Varre a lista de papéis e verifica se o papel a ser
6670   - removido se encontra em uma das três listas de papeis da classe
6671   - Papel (ref, membro ou admin) */
  6481 + //Check if the role is being referenced in other roles
6672 6482 itr=roles.begin();
6673 6483 itr_end=roles.end();
6674 6484 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6675 6485 {
6676   - //Obtém um papel
6677 6486 role_aux=dynamic_cast<Role *>(*itr);
6678 6487 itr++;
6679 6488
6680 6489 for(i1=0; i1 < 3 && (!exclusion_mode || (exclusion_mode && !refer)); i1++)
6681 6490 {
6682   - //Obtém a quantidade de papeis presentes na lista atual (tipo_papel[i1])
6683 6491 count=role_aux->getRoleCount(role_types[i1]);
6684 6492 for(i=0; i < count && !refer; i++)
6685 6493 {
6686   - /* Caso o papel a ser excluído seja igual ao elemento atual
6687   - da lista de papéis do papel aux */
6688 6494 if(role_aux->getRole(role_types[i1], i)==role)
6689 6495 {
6690 6496 refer=true;
@@ -6694,19 +6500,14 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6694 6500 }
6695 6501 }
6696 6502
6697   - /* Varre todas as listas de objetos os quais pode pertencer a
6698   - um dono e verifica se o mesmos não estão referenciando
6699   - o dono a ser removido */
6700 6503 for(i=0; i < 13 && (!exclusion_mode || (exclusion_mode && !refer)); i++)
6701 6504 {
6702   - //Obtém uma lista
6703 6505 obj_list=getObjectList(obj_types[i]);
6704 6506 itr=obj_list->begin();
6705 6507 itr_end=obj_list->end();
6706 6508
6707 6509 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6708 6510 {
6709   - //Verifica se o objeto não referencia o papel
6710 6511 if((*itr)->getOwner()==role)
6711 6512 {
6712 6513 refer=true;
@@ -6716,8 +6517,7 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6716 6517 }
6717 6518 }
6718 6519
6719   - /*Caso especial: Verifica se o papel é a ser removido é dono
6720   - do próprio banco de dados */
  6520 + //Special case: check if the role to be removed is the owner of the database
6721 6521 if((!exclusion_mode || (exclusion_mode && !refer)) && this->getOwner()==role)
6722 6522 {
6723 6523 refer=true;
@@ -6733,26 +6533,19 @@ void DatabaseModel::getObjectReferences(BaseObject *object, vector<BaseObject *>
6733 6533 Index *ind=NULL;
6734 6534 Constraint *rest=NULL;
6735 6535
6736   - /* Varre a lista de tabelas e verifica se estas e seus índices
6737   - não estão referenciando o espaço de tabelas a ser removido */
6738 6536 itr=tables.begin();
6739 6537 itr_end=tables.end();
6740 6538
6741 6539 while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !refer)))
6742 6540 {