Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Browse files

pgsqltypes files refactoring checkpoint.

  • Loading branch information...
commit c0c7a410f50990c85dea8e513d9ec15e4ce347f5 1 parent b20a205
@rkhaotix rkhaotix authored
Showing with 489 additions and 495 deletions.
  1. +15 −15 libobjrenderer/src/ogsubitemobjeto.cpp
  2. +1 −1  libobjrenderer/src/ogsubitemobjeto.h
  3. +14 −14 libpgmodeler/src/constraint.cpp
  4. +3 −3 libpgmodeler/src/constraint.h
  5. +2 −2 libpgmodeler/src/function.cpp
  6. +3 −3 libpgmodeler/src/function.h
  7. +2 −2 libpgmodeler/src/index.cpp
  8. +3 −3 libpgmodeler/src/index.h
  9. +39 −39 libpgmodeler/src/modelobd.cpp
  10. +2 −2 libpgmodeler/src/operationlist.cpp
  11. +2 −2 libpgmodeler/src/operatorclass.cpp
  12. +3 −3 libpgmodeler/src/operatorclass.h
  13. +2 −2 libpgmodeler/src/operatorfamily.cpp
  14. +3 −3 libpgmodeler/src/operatorfamily.h
  15. +179 −179 libpgmodeler/src/pgsqltypes.cpp
  16. +96 −102 libpgmodeler/src/pgsqltypes.h
  17. +12 −12 libpgmodeler/src/relationship.cpp
  18. +4 −4 libpgmodeler/src/rule.cpp
  19. +6 −6 libpgmodeler/src/rule.h
  20. +11 −11 libpgmodeler/src/tabela.cpp
  21. +1 −1  libpgmodeler/src/tabela.h
  22. +9 −9 libpgmodeler/src/trigger.cpp
  23. +3 −3 libpgmodeler/src/trigger.h
  24. +2 −2 libpgmodeler_ui/src/classeoperadoreswidget.cpp
  25. +1 −1  libpgmodeler_ui/src/colunawidget.cpp
  26. +2 −2 libpgmodeler_ui/src/familiaoperadoreswidget.cpp
  27. +1 −1  libpgmodeler_ui/src/funcaowidget.cpp
  28. +8 −8 libpgmodeler_ui/src/gatilhowidget.cpp
  29. +3 −3 libpgmodeler_ui/src/indicewidget.cpp
  30. +6 −6 libpgmodeler_ui/src/modelowidget.cpp
  31. +4 −4 libpgmodeler_ui/src/regrawidget.cpp
  32. +26 −26 libpgmodeler_ui/src/restricaowidget.cpp
  33. +7 −7 libpgmodeler_ui/src/tabelawidget.cpp
  34. +7 −7 libpgmodeler_ui/src/tipopgsqlwidget.cpp
  35. +2 −2 libpgmodeler_ui/src/tipopgsqlwidget.h
  36. +5 −5 libpgmodeler_ui/src/visaoobjetoswidget.cpp
View
30 libobjrenderer/src/ogsubitemobjeto.cpp
@@ -35,7 +35,7 @@ OGSubItemObjeto::~OGSubItemObjeto(void)
}
}
-void OGSubItemObjeto::configurarDescritor(TipoRestricao tipo_rest)
+void OGSubItemObjeto::configurarDescritor(ConstraintType tipo_rest)
{
ObjectType tipo_obj=BASE_OBJECT;
Column *coluna=dynamic_cast<Column *>(this->obterObjetoOrigem());
@@ -105,7 +105,7 @@ void OGSubItemObjeto::configurarDescritor(TipoRestricao tipo_rest)
QGraphicsPolygonItem *desc=dynamic_cast<QGraphicsPolygonItem *>(descritor);
//Cria um polígono conforme o tipo de restrição da coluna
- if(tipo_rest==TipoRestricao::primary_key)
+ if(tipo_rest==ConstraintType::primary_key)
{
atrib=ParsersAttributes::PK_COLUMN;
pol.append(QPointF(2,0)); pol.append(QPointF(0,2)); pol.append(QPointF(0,7));
@@ -114,7 +114,7 @@ void OGSubItemObjeto::configurarDescritor(TipoRestricao tipo_rest)
pol.append(QPointF(7,5)); pol.append(QPointF(9,7)); pol.append(QPointF(9,3));
pol.append(QPointF(3,3)); pol.append(QPointF(3,1));
}
- else if(tipo_rest==TipoRestricao::foreign_key)
+ else if(tipo_rest==ConstraintType::foreign_key)
{
atrib=ParsersAttributes::FK_COLUMN;
pol.append(QPointF(0,3)); pol.append(QPointF(0,6)); pol.append(QPointF(4,6));
@@ -122,7 +122,7 @@ void OGSubItemObjeto::configurarDescritor(TipoRestricao tipo_rest)
pol.append(QPointF(9,4)); pol.append(QPointF(5,0)); pol.append(QPointF(4,0));
pol.append(QPointF(4,3));
}
- else if(tipo_rest==TipoRestricao::unique)
+ else if(tipo_rest==ConstraintType::unique)
{
atrib=ParsersAttributes::UQ_COLUMN;
pol.append(QPointF(4,0)); pol.append(QPointF(0,4)); pol.append(QPointF(0,5));
@@ -184,7 +184,7 @@ void OGSubItemObjeto::configurarObjeto(void)
QString str_rest;
TableObject *objeto_tab=dynamic_cast<TableObject *>(this->obterObjetoOrigem());
Column *coluna=dynamic_cast<Column *>(objeto_tab);
- TipoRestricao tipo_rest=TipoRestricao::null;
+ ConstraintType tipo_rest=ConstraintType::null;
//Caso seja uma coluna
if(coluna)
@@ -198,17 +198,17 @@ void OGSubItemObjeto::configurarObjeto(void)
if(str_rest.find(TEXTO_PRIMARY_KEY)>=0)
{
fmt=config_fonte[ParsersAttributes::PK_COLUMN];
- tipo_rest=TipoRestricao::primary_key;
+ tipo_rest=ConstraintType::primary_key;
}
else if(str_rest.find(TEXTO_FOREIGN_KEY)>=0)
{
fmt=config_fonte[ParsersAttributes::FK_COLUMN];
- tipo_rest=TipoRestricao::foreign_key;
+ tipo_rest=ConstraintType::foreign_key;
}
else if(str_rest.find(TEXTO_UNIQUE)>=0)
{
fmt=config_fonte[ParsersAttributes::UQ_COLUMN];
- tipo_rest=TipoRestricao::unique;
+ tipo_rest=ConstraintType::unique;
}
else if(str_rest.find(TEXTO_NOT_NULL)>=0)
fmt=config_fonte[ParsersAttributes::NN_COLUMN];
@@ -277,10 +277,10 @@ void OGSubItemObjeto::configurarObjeto(void)
str_rest+=(~gatilho->getFiringType()).mid(0,1);
str_rest+=SEPARADOR_REST;
- for(unsigned i=TipoEvento::on_insert; i < TipoEvento::on_truncate; i++)
+ for(unsigned i=EventType::on_insert; i < EventType::on_truncate; i++)
{
- if(gatilho->isExecuteOnEvent(TipoEvento(i)))
- str_rest+=(~TipoEvento(i)).mid(3,1);
+ if(gatilho->isExecuteOnEvent(EventType(i)))
+ str_rest+=(~EventType(i)).mid(3,1);
}
str_rest=str_rest.lower();
}
@@ -428,7 +428,7 @@ QString OGSubItemObjeto::obterStringRestricoes(Column *coluna)
Constraint *restricao=NULL;
vector<Constraint *>::iterator itr,itr_end;
vector<Constraint *> restricoes;
- TipoRestricao tipo_rest;
+ ConstraintType tipo_rest;
unsigned i, qtd;
qtd=tabela->obterNumRestricoes();
@@ -452,11 +452,11 @@ QString OGSubItemObjeto::obterStringRestricoes(Column *coluna)
//Para cada tipo de constraint concatena-se o texto referente
// a mesma e um separadar de textos de constraints
- if(tipo_rest==TipoRestricao::primary_key)
+ if(tipo_rest==ConstraintType::primary_key)
str_rest=TEXTO_PRIMARY_KEY + SEPARADOR_REST;
- else if(tipo_rest==TipoRestricao::foreign_key)
+ else if(tipo_rest==ConstraintType::foreign_key)
str_rest+=TEXTO_FOREIGN_KEY + SEPARADOR_REST;
- else if(tipo_rest==TipoRestricao::unique)
+ else if(tipo_rest==ConstraintType::unique)
str_rest+=TEXTO_UNIQUE + SEPARADOR_REST;
}
}
View
2  libobjrenderer/src/ogsubitemobjeto.h
@@ -56,7 +56,7 @@ class OGSubItemObjeto: public ObjetoGrafico
TEXTO_UNIQUE;
//Configura o descritor do subitem conforme o tipo do objeto de origem
- void configurarDescritor(TipoRestricao tipo_rest=BaseType::null);
+ void configurarDescritor(ConstraintType tipo_rest=BaseType::null);
/* Sobrecarga do método da classe QGraphicsItemGroup::itemChange() e sua implentação
controla as alterações durante a seleção e movimentação do objeto. Esta nova implementação
View
28 libpgmodeler/src/constraint.cpp
@@ -31,7 +31,7 @@ Constraint::~Constraint(void)
removeColumns();
}
-void Constraint::setConstraintType(TipoRestricao constr_type)
+void Constraint::setConstraintType(ConstraintType constr_type)
{
this->constr_type=constr_type;
}
@@ -90,7 +90,7 @@ void Constraint::addColumn(Column *column, unsigned col_type)
.arg(QString::fromUtf8(this->getName()))
.arg(BaseObject::getTypeName(OBJ_CONSTRAINT)),
ERR_ASG_NOT_ALOC_COLUMN,__PRETTY_FUNCTION__,__FILE__,__LINE__);
- else if(constr_type!=TipoRestricao::check)
+ else if(constr_type!=ConstraintType::check)
{
//Adds the column only if the column doesn't exists on the internal list
if(!isColumnExists(column,col_type))
@@ -108,8 +108,8 @@ void Constraint::setTablespace(Tablespace *tabspc)
try
{
if(tabspc &&
- constr_type!=TipoRestricao::primary_key &&
- constr_type!=TipoRestricao::unique)
+ constr_type!=ConstraintType::primary_key &&
+ constr_type!=ConstraintType::unique)
throw Exception(ERR_ASG_TABSPC_INV_CONSTR_TYPE,__PRETTY_FUNCTION__,__FILE__,__LINE__);
BaseObject::setTablespace(tabspc);
@@ -194,7 +194,7 @@ unsigned Constraint::getFillFactor(void)
return(fill_factor);
}
-TipoRestricao Constraint::getConstraintType(void)
+ConstraintType Constraint::getConstraintType(void)
{
return(constr_type);
}
@@ -356,16 +356,16 @@ QString Constraint::getCodeDefinition(unsigned def_type, bool inc_addedbyrel)
switch(!constr_type)
{
- case TipoRestricao::check:
+ case ConstraintType::check:
attrib=ParsersAttributes::CK_CONSTR;
break;
- case TipoRestricao::primary_key:
+ case ConstraintType::primary_key:
attrib=ParsersAttributes::PK_CONSTR;
break;
- case TipoRestricao::foreign_key:
+ case ConstraintType::foreign_key:
attrib=ParsersAttributes::FK_CONSTR;
break;
- case TipoRestricao::unique:
+ case ConstraintType::unique:
attrib=ParsersAttributes::UQ_CONSTR;
break;
}
@@ -376,7 +376,7 @@ QString Constraint::getCodeDefinition(unsigned def_type, bool inc_addedbyrel)
attributes[ParsersAttributes::DEL_ACTION]=(~del_action);
attributes[ParsersAttributes::EXPRESSION]=check_expr;
- if(constr_type!=TipoRestricao::check)
+ if(constr_type!=ConstraintType::check)
{
setColumnsAttribute(SOURCE_COLS, def_type, inc_addedbyrel);
@@ -385,7 +385,7 @@ QString Constraint::getCodeDefinition(unsigned def_type, bool inc_addedbyrel)
this means the constraint is configured correctly, otherwise don't generates
the attribute forcing the schema parser to return an error because the foreign key is
misconfigured. */
- if(constr_type==TipoRestricao::foreign_key && columns.size() == ref_columns.size())
+ if(constr_type==ConstraintType::foreign_key && columns.size() == ref_columns.size())
setColumnsAttribute(REFERENCED_COLS, def_type, inc_addedbyrel);
}
@@ -401,11 +401,11 @@ QString Constraint::getCodeDefinition(unsigned def_type, bool inc_addedbyrel)
inside the parent table construction by the use of 'decl-in-table' schema attribute.
Note: For reference track reason foreign keys ALWAYS will be created in a separeted (ALTER TABLE)
command outside the parent table declaration */
- if(constr_type!=TipoRestricao::foreign_key &&
- (!isReferRelationshipColumn() || constr_type==TipoRestricao::primary_key))
+ if(constr_type!=ConstraintType::foreign_key &&
+ (!isReferRelationshipColumn() || constr_type==ConstraintType::primary_key))
attributes[ParsersAttributes::DECL_IN_TABLE]="1";
- if(constr_type==TipoRestricao::primary_key || constr_type==TipoRestricao::unique)
+ if(constr_type==ConstraintType::primary_key || constr_type==ConstraintType::unique)
attributes[ParsersAttributes::FACTOR]=QString("%1").arg(fill_factor);
else
attributes[ParsersAttributes::FACTOR]="";
View
6 libpgmodeler/src/constraint.h
@@ -30,7 +30,7 @@
class Constraint: public TableObject{
private:
//Type of the constraint (primary key, foreign key, unique or check)
- TipoRestricao constr_type;
+ ConstraintType constr_type;
//Indicates if the constraint is deferrable (only for foreign key)
bool deferrable;
@@ -83,7 +83,7 @@ class Constraint: public TableObject{
void addColumn(Column *column, unsigned col_type);
//Defines the constraint type
- void setConstraintType(TipoRestricao constr_type);
+ void setConstraintType(ConstraintType constr_type);
/* Defines the type of action on foreign keys (ON DELETE and ON UPDATE).
If the parameter 'upd' is set, it will be configured the action on update
@@ -138,7 +138,7 @@ class Constraint: public TableObject{
void removeColumns(void);
//Returns the constraint type
- TipoRestricao getConstraintType(void);
+ ConstraintType getConstraintType(void);
//Returns the check expression
QString getCheckExpression(void);
View
4 libpgmodeler/src/function.cpp
@@ -232,7 +232,7 @@ void Function::setReturnType(TipoPgSQL type)
return_type=type;
}
-void Function::setFunctionType(TipoFuncao func_type)
+void Function::setFunctionType(FunctionType func_type)
{
function_type=func_type;
}
@@ -284,7 +284,7 @@ TipoPgSQL Function::getReturnType(void)
return(return_type);
}
-TipoFuncao Function::getFunctionType(void)
+FunctionType Function::getFunctionType(void)
{
return(function_type);
}
View
6 libpgmodeler/src/function.h
@@ -83,7 +83,7 @@ class Function: public BaseObject {
TipoComportamento behavior_type;
//Function type. It can be VOLATILE, IMMUTABLE, STABLE
- TipoFuncao function_type;
+ FunctionType function_type;
//Function return type
TipoPgSQL return_type;
@@ -151,7 +151,7 @@ class Function: public BaseObject {
void setBehaviorType(TipoComportamento behav_type);
//Defines the function type (VOLATILE, IMMUTABLE, STABLE)
- void setFunctionType(TipoFuncao func_type);
+ void setFunctionType(FunctionType func_type);
//Defines the function return type
void setReturnType(TipoPgSQL type);
@@ -196,7 +196,7 @@ class Function: public BaseObject {
TipoComportamento getBehaviorType(void);
//Returns the function type
- TipoFuncao getFunctionType(void);
+ FunctionType getFunctionType(void);
//Returns the function returned type
TipoPgSQL getReturnType(void);
View
4 libpgmodeler/src/index.cpp
@@ -158,7 +158,7 @@ void Index::setFillFactor(unsigned factor)
fill_factor=factor;
}
-void Index::setIndexingType(TipoIndexacao idx_type)
+void Index::setIndexingType(IndexingType idx_type)
{
this->indexing_type=idx_type;
}
@@ -195,7 +195,7 @@ bool Index::getIndexAttribute(unsigned attrib_id)
return(index_attribs[attrib_id]);
}
-TipoIndexacao Index::getIndexingType(void)
+IndexingType Index::getIndexingType(void)
{
return(indexing_type);
}
View
6 libpgmodeler/src/index.h
@@ -37,7 +37,7 @@ class Index: public TableObject{
unsigned fill_factor;
//Indexing method used by the index
- TipoIndexacao indexing_type;
+ IndexingType indexing_type;
//Boolean attributes that define some index features (UNIQUE, CONCURRENT, FAST UPDATE)
bool index_attribs[3];
@@ -79,7 +79,7 @@ class Index: public TableObject{
void setConditionalExpression(const QString &expr);
//Defines the indexing method used by the index
- void setIndexingType(TipoIndexacao idx_type);
+ void setIndexingType(IndexingType idx_type);
/* Configures the attributes for the indexs. These attributes can be
referencede using the UNIQUE, CONCURRENT and FAST_UPDATE constants */
@@ -95,7 +95,7 @@ class Index: public TableObject{
unsigned getElementCount(void);
//Returns the indexing method used by the index
- TipoIndexacao getIndexingType(void);
+ IndexingType getIndexingType(void);
//Returns the current state of one index attribute (UNIQUE, CONCURRENT, FAST UPDATE)
bool getIndexAttribute(unsigned attrib_id);
View
78 libpgmodeler/src/modelobd.cpp
@@ -724,7 +724,7 @@ void ModeloBD::adicionarTabela(Tabela *tabela, int idx_obj)
/* Ao ser inserido uma nova tabela a mesma tem
seu nome é adicionad lista de tipos válidos
do PostgreSQL */
- TipoPgSQL::adicionarTipoUsuario(tabela->getName(true), tabela, this, ConfigTipoUsuario::TIPO_TABELA);
+ TipoPgSQL::adicionarTipoUsuario(tabela->getName(true), tabela, this, UserTypeConfig::TABLE_TYPE);
atualizarRelFkTabela(tabela);
}
@@ -815,7 +815,7 @@ void ModeloBD::adicionarSequencia(Sequence *sequencia, int idx_obj)
/* Ao ser inserido uma nova sequencia a mesma tem
seu nome é adicionad lista de tipos válidos
do PostgreSQL */
- TipoPgSQL::adicionarTipoUsuario(sequencia->getName(true), sequencia, this, ConfigTipoUsuario::TIPO_SEQUENCIA);
+ TipoPgSQL::adicionarTipoUsuario(sequencia->getName(true), sequencia, this, UserTypeConfig::SEQUENCE_TYPE);
}
catch(Exception &e)
{
@@ -1489,7 +1489,7 @@ void ModeloBD::obterXMLObjetosEspeciais(void)
adicionadas por relacionamentos foi criada pelo usuário. */
enc=(!restricao->isAddedByRelationship() &&
restricao->isReferRelationshipColumn() &&
- restricao->getConstraintType()!=TipoRestricao::primary_key);
+ restricao->getConstraintType()!=ConstraintType::primary_key);
/* Caso uma restrição seja encontrada obedecendo a condição acima,
armazena sua definição XML na lista de xml de objetos especiais */
@@ -2217,7 +2217,7 @@ void ModeloBD::adicionarDominio(Domain *dominio, int idx_obj)
/* Ao ser inserido um novo tipo o mesmo tem
seu nome é adicionad lista de tipos válidos
do PostgreSQL */
- TipoPgSQL::adicionarTipoUsuario(dominio->getName(true), dominio, this, ConfigTipoUsuario::TIPO_DOMINIO);
+ TipoPgSQL::adicionarTipoUsuario(dominio->getName(true), dominio, this, UserTypeConfig::DOMAIN_TYPE);
}
catch(Exception &e)
{
@@ -2391,7 +2391,7 @@ void ModeloBD::adicionarTipo(Type *tipo, int idx_obj)
/* Ao ser inserido um novo tipo o mesmo tem
seu nome é adicionad lista de tipos válidos
do PostgreSQL */
- TipoPgSQL::adicionarTipoUsuario(tipo->getName(true), tipo, this, ConfigTipoUsuario::TIPO_BASE);
+ TipoPgSQL::adicionarTipoUsuario(tipo->getName(true), tipo, this, UserTypeConfig::BASE_TYPE);
}
catch(Exception &e)
{
@@ -3524,7 +3524,7 @@ Function *ModeloBD::criarFuncao(void)
//Define o tipo da função, caso o atributo esteja marcado no XML
if(!atributos[ParsersAttributes::FUNCTION_TYPE].isEmpty())
- funcao->setFunctionType(TipoFuncao(atributos[ParsersAttributes::FUNCTION_TYPE]));
+ funcao->setFunctionType(FunctionType(atributos[ParsersAttributes::FUNCTION_TYPE]));
//Define o tipo de segurança da função, caso o atributo esteja marcado no XML
if(!atributos[ParsersAttributes::SECURITY_TYPE].isEmpty())
@@ -3740,8 +3740,8 @@ TipoPgSQL ModeloBD::criarTipoPgSQL(void)
void *ptipo=NULL;
//TipoPgSQL tipo;
bool enc=false, com_timezone;
- TipoIntervalo tipo_interv;
- TipoEspacial tipo_esp;
+ IntervalType tipo_interv;
+ SpatialType tipo_esp;
//Obtém os atributos do tipo
@@ -3760,7 +3760,7 @@ TipoPgSQL ModeloBD::criarTipoPgSQL(void)
tipo_interv=atributos[ParsersAttributes::INTERVAL_TYPE];
if(!atributos[ParsersAttributes::SPATIAL_TYPE].isEmpty())
- tipo_esp=TipoEspacial(atributos[ParsersAttributes::SPATIAL_TYPE],
+ tipo_esp=SpatialType(atributos[ParsersAttributes::SPATIAL_TYPE],
atributos[ParsersAttributes::VARIATION].toUInt());
nome=atributos[ParsersAttributes::NAME];
@@ -3774,10 +3774,10 @@ TipoPgSQL ModeloBD::criarTipoPgSQL(void)
{
//Obtém a lista de tipos definidios pelo usuario
TipoPgSQL::obterTiposUsuario(vet_ptipos, this,
- ConfigTipoUsuario::TIPO_BASE |
- ConfigTipoUsuario::TIPO_DOMINIO |
- ConfigTipoUsuario::TIPO_TABELA |
- ConfigTipoUsuario::TIPO_SEQUENCIA);
+ UserTypeConfig::BASE_TYPE |
+ UserTypeConfig::DOMAIN_TYPE |
+ UserTypeConfig::TABLE_TYPE |
+ UserTypeConfig::SEQUENCE_TYPE);
itr=vet_ptipos.begin();
itr_end=vet_ptipos.end();
@@ -4386,7 +4386,7 @@ OperatorClass *ModeloBD::criarClasseOperadores(void)
//Obtém os atributos
XMLParser::getElementAttributes(atributos);
- classe_op->setIndexingType(TipoIndexacao(atributos[ParsersAttributes::INDEX_TYPE]));
+ classe_op->setIndexingType(IndexingType(atributos[ParsersAttributes::INDEX_TYPE]));
classe_op->setDefault(atributos[ParsersAttributes::DEFAULT]==ParsersAttributes::_TRUE_);
tipos_elem[ParsersAttributes::FUNCTION]=OperatorClassElement::FUNCTION_ELEM;
@@ -4495,7 +4495,7 @@ OperatorFamily *ModeloBD::criarFamiliaOperadores(void)
XMLParser::getElementAttributes(atributos);
//Definindo os valores de atributos básicos do objeto
- familia_op->setIndexingType(TipoIndexacao(atributos[ParsersAttributes::INDEX_TYPE]));
+ familia_op->setIndexingType(IndexingType(atributos[ParsersAttributes::INDEX_TYPE]));
}
catch(Exception &e)
{
@@ -4727,7 +4727,7 @@ Constraint *ModeloBD::criarRestricao(BaseObject *objeto)
Relationship *relacao=NULL;
QString elem, str_aux;
bool postergavel, ins_rest_tabela=false;
- TipoRestricao tipo_rest;
+ ConstraintType tipo_rest;
QStringList lista_cols;
int qtd, i;
unsigned tipo_coluna;
@@ -4777,13 +4777,13 @@ Constraint *ModeloBD::criarRestricao(BaseObject *objeto)
//Configurando o tipo da restrição
if(atributos[ParsersAttributes::TYPE]==ParsersAttributes::CK_CONSTR)
- tipo_rest=TipoRestricao::check;
+ tipo_rest=ConstraintType::check;
else if(atributos[ParsersAttributes::TYPE]==ParsersAttributes::PK_CONSTR)
- tipo_rest=TipoRestricao::primary_key;
+ tipo_rest=ConstraintType::primary_key;
else if(atributos[ParsersAttributes::TYPE]==ParsersAttributes::FK_CONSTR)
- tipo_rest=TipoRestricao::foreign_key;
+ tipo_rest=ConstraintType::foreign_key;
else
- tipo_rest=TipoRestricao::unique;
+ tipo_rest=ConstraintType::unique;
restricao->setConstraintType(tipo_rest);
if(!atributos[ParsersAttributes::FACTOR].isEmpty())
@@ -4828,13 +4828,13 @@ Constraint *ModeloBD::criarRestricao(BaseObject *objeto)
significando que a mesma está declarada fora dos dois blocos indicados.
Adicionalmente é necessário verificar o tipo da restrição para se
ter certeza que a mesma é uma chave primária. */
- if(!objeto && tipo_rest==TipoRestricao::primary_key)
+ if(!objeto && tipo_rest==ConstraintType::primary_key)
throw Exception(Exception::getErrorMessage(ERR_INV_PRIM_KEY_ALOCATION)
.arg(QString::fromUtf8(restricao->getName())),
ERR_INV_PRIM_KEY_ALOCATION,__PRETTY_FUNCTION__,__FILE__,__LINE__);
//Efetuando configurações específicas para chaves estrangeiras
- if(tipo_rest==TipoRestricao::foreign_key /*&& tipo_objeto==OBJETO_TABELA*/)
+ if(tipo_rest==ConstraintType::foreign_key /*&& tipo_objeto==OBJETO_TABELA*/)
{
//Define se a restrição é postergavel (apenas para chaves estrangeiras)
postergavel=(atributos[ParsersAttributes::DEFERRABLE]==ParsersAttributes::_TRUE_);
@@ -4954,7 +4954,7 @@ Constraint *ModeloBD::criarRestricao(BaseObject *objeto)
if(ins_rest_tabela)
{
//Caso a restrição criada não seja uma chave primária insere-a normalmente na tabela
- if(restricao->getConstraintType()!=TipoRestricao::primary_key)
+ if(restricao->getConstraintType()!=ConstraintType::primary_key)
{
tabela->adicionarRestricao(restricao);
@@ -5249,19 +5249,19 @@ Trigger *ModeloBD::criarGatilho(Tabela *tabela)
definirAtributosBasicos(gatilho);
//Marcando os eventos de execução do gatilho
- gatilho->setEvent(TipoEvento::on_insert,
+ gatilho->setEvent(EventType::on_insert,
(atributos[ParsersAttributes::INS_EVENT]==
ParsersAttributes::_TRUE_));
- gatilho->setEvent(TipoEvento::on_delete,
+ gatilho->setEvent(EventType::on_delete,
(atributos[ParsersAttributes::DEL_EVENT]==
ParsersAttributes::_TRUE_));
- gatilho->setEvent(TipoEvento::on_update,
+ gatilho->setEvent(EventType::on_update,
(atributos[ParsersAttributes::UPD_EVENT]==
ParsersAttributes::_TRUE_));
- gatilho->setEvent(TipoEvento::on_truncate,
+ gatilho->setEvent(EventType::on_truncate,
(atributos[ParsersAttributes::TRUNC_EVENT]==
ParsersAttributes::_TRUE_));
@@ -6108,9 +6108,9 @@ void ModeloBD::validarRelacObjetoTabela(TableObject *objeto, Tabela *tabela_pai)
> Caso seja uma coluna e a mesma é referenciada pela chave primária da tabela pai
> Caso seja uma restrição e a mesma seja uma chave primária da tabela */
revalidar_rels=((tipo==OBJ_COLUMN &&
- tabela_pai->restricaoReferenciaColuna(dynamic_cast<Column *>(objeto), TipoRestricao::primary_key)) ||
+ tabela_pai->restricaoReferenciaColuna(dynamic_cast<Column *>(objeto), ConstraintType::primary_key)) ||
(tipo==OBJ_CONSTRAINT &&
- dynamic_cast<Constraint *>(objeto)->getConstraintType()==TipoRestricao::primary_key));
+ dynamic_cast<Constraint *>(objeto)->getConstraintType()==ConstraintType::primary_key));
/* Caso seja uma coluna, verfica se a tabela pai participa de um relacionamento
de generalização como tabela de destino (aquela que tem suas colunas copiadas
@@ -6332,11 +6332,11 @@ QString ModeloBD::getCodeDefinition(unsigned tipo_def, bool exportar_arq)
do modelo */
if((tipo_def==SchemaParser::XML_DEFINITION ||
(tipo_def==SchemaParser::SQL_DEFINITION &&
- restricao->getConstraintType()!=TipoRestricao::foreign_key)) &&
+ restricao->getConstraintType()!=ConstraintType::foreign_key)) &&
(!restricao->isAddedByLinking() &&
- ((restricao->getConstraintType()!=TipoRestricao::primary_key && restricao->isReferRelationshipColumn()) ||
- (restricao->getConstraintType()==TipoRestricao::foreign_key))))
+ ((restricao->getConstraintType()!=ConstraintType::primary_key && restricao->isReferRelationshipColumn()) ||
+ (restricao->getConstraintType()==ConstraintType::foreign_key))))
{
//Armazena o objeto em si no mapa de objetos
mapa_objetos[restricao->getObjectId()]=restricao;
@@ -6880,7 +6880,7 @@ void ModeloBD::obterDependenciasObjeto(BaseObject *objeto, vector<BaseObject *>
for(i=0; i < qtd; i++)
{
rest=dynamic_cast<Constraint *>(rel->getConstraint(i));
- if(rest->getConstraintType()==TipoRestricao::foreign_key)
+ if(rest->getConstraintType()==ConstraintType::foreign_key)
obterDependenciasObjeto(rest->getReferencedTable(), vet_deps, inc_dep_indiretas);
if(rest->getTablespace())
@@ -6924,7 +6924,7 @@ void ModeloBD::obterDependenciasObjeto(BaseObject *objeto, vector<BaseObject *>
rest=dynamic_cast<Constraint *>(tab->obterRestricao(i));
if(inc_dep_indiretas &&
!rest->isAddedByLinking() &&
- rest->getConstraintType()==TipoRestricao::foreign_key)
+ rest->getConstraintType()==ConstraintType::foreign_key)
obterDependenciasObjeto(rest->getReferencedTable(), vet_deps, inc_dep_indiretas);
if(!rest->isAddedByLinking() && rest->getTablespace())
@@ -7095,7 +7095,7 @@ void ModeloBD::obterReferenciasObjeto(BaseObject *objeto, vector<BaseObject *> &
for(i=0; i < qtd&& (!modo_exclusao || (modo_exclusao && !refer)); i++)
{
rest=tab->obterRestricao(i);
- if(rest->getConstraintType()==TipoRestricao::foreign_key &&
+ if(rest->getConstraintType()==ConstraintType::foreign_key &&
rest->getReferencedTable()==tabela)
{
refer=true;
@@ -7918,19 +7918,19 @@ BaseObject *ModeloBD::obterObjetoTipoPgSQL(TipoPgSQL tipo)
{
switch(tipo.obterConfTipoUsuario())
{
- case ConfigTipoUsuario::TIPO_BASE:
+ case UserTypeConfig::BASE_TYPE:
return(this->obterObjeto(*tipo, OBJ_TYPE));
break;
- case ConfigTipoUsuario::TIPO_DOMINIO:
+ case UserTypeConfig::DOMAIN_TYPE:
return(this->obterObjeto(*tipo, OBJ_DOMAIN));
break;
- case ConfigTipoUsuario::TIPO_TABELA:
+ case UserTypeConfig::TABLE_TYPE:
return(this->obterObjeto(*tipo, OBJ_TABLE));
break;
- case ConfigTipoUsuario::TIPO_SEQUENCIA:
+ case UserTypeConfig::SEQUENCE_TYPE:
return(this->obterObjeto(*tipo, OBJ_SEQUENCE));
break;
View
4 libpgmodeler/src/operationlist.cpp
@@ -807,7 +807,7 @@ void OperationList::executeOperation(Operation *oper, bool redo)
parent_tab->adicionarObjeto(dynamic_cast<TableObject *>(object), oper->object_idx);
if(object->getObjectType()==OBJ_CONSTRAINT &&
- dynamic_cast<Constraint *>(object)->getConstraintType()==TipoRestricao::foreign_key)
+ dynamic_cast<Constraint *>(object)->getConstraintType()==ConstraintType::foreign_key)
model->atualizarRelFkTabela(parent_tab);
}
else if(parent_rel)
@@ -848,7 +848,7 @@ void OperationList::executeOperation(Operation *oper, bool redo)
model->validarRelacObjetoTabela(dynamic_cast<TableObject *>(object), parent_tab);
if(object->getObjectType()==OBJ_CONSTRAINT &&
- dynamic_cast<Constraint *>(object)->getConstraintType()==TipoRestricao::foreign_key)
+ dynamic_cast<Constraint *>(object)->getConstraintType()==ConstraintType::foreign_key)
model->atualizarRelFkTabela(parent_tab);
}
else if(parent_rel)
View
4 libpgmodeler/src/operatorclass.cpp
@@ -31,7 +31,7 @@ void OperatorClass::setFamily(OperatorFamily *family)
this->family=family;
}
-void OperatorClass::setIndexingType(TipoIndexacao index_type)
+void OperatorClass::setIndexingType(IndexingType index_type)
{
this->indexing_type=index_type;
}
@@ -127,7 +127,7 @@ OperatorFamily *OperatorClass::getFamily(void)
return(family);
}
-TipoIndexacao OperatorClass::getIndexingType(void)
+IndexingType OperatorClass::getIndexingType(void)
{
return(indexing_type);
}
View
6 libpgmodeler/src/operatorclass.h
@@ -37,7 +37,7 @@ class OperatorClass: public BaseObject {
OperatorFamily *family;
//Indexing type (method) adopted by the operator class
- TipoIndexacao indexing_type;
+ IndexingType indexing_type;
/* Indicates if the operator class is the default for the
specified data type */
@@ -61,7 +61,7 @@ class OperatorClass: public BaseObject {
void setFamily(OperatorFamily *family);
//Set the indexing type used by the operator class
- void setIndexingType(TipoIndexacao index_type);
+ void setIndexingType(IndexingType index_type);
//Sets if the opertor class is default for the specified data type
void setDefault(bool value);
@@ -76,7 +76,7 @@ class OperatorClass: public BaseObject {
//Methods used to obtain the class attributes
TipoPgSQL getDataType(void);
OperatorFamily *getFamily(void);
- TipoIndexacao getIndexingType(void);
+ IndexingType getIndexingType(void);
bool isDefault(void);
unsigned getElementCount(void);
View
4 libpgmodeler/src/operatorfamily.cpp
@@ -6,12 +6,12 @@ OperatorFamily::OperatorFamily(void)
attributes[ParsersAttributes::INDEX_TYPE]="";
}
-void OperatorFamily::setIndexingType(TipoIndexacao idx_type)
+void OperatorFamily::setIndexingType(IndexingType idx_type)
{
indexing_type=idx_type;
}
-TipoIndexacao OperatorFamily::getIndexingType(void)
+IndexingType OperatorFamily::getIndexingType(void)
{
return(indexing_type);
}
View
6 libpgmodeler/src/operatorfamily.h
@@ -27,16 +27,16 @@
class OperatorFamily: public BaseObject {
private:
//Indexing type used by the operator family
- TipoIndexacao indexing_type;
+ IndexingType indexing_type;
public:
OperatorFamily(void);
//Sets the indexing type of the operator family
- void setIndexingType(TipoIndexacao idx_type);
+ void setIndexingType(IndexingType idx_type);
//Returns the indexing type of the operator family
- TipoIndexacao getIndexingType(void);
+ IndexingType getIndexingType(void);
//Returns the SQL / XML code definition for the operator family
QString getCodeDefinition(unsigned def_type, bool reduced_form);
View
358 libpgmodeler/src/pgsqltypes.cpp
@@ -3,7 +3,7 @@
/********************
* CLASSE: TipoBase *
********************/
-QString BaseType::tipos[types_count]=
+QString BaseType::type_list[types_count]=
{
/* Tipo vazio, quando se instância a classe TipoBase ao usar o operador ~
este será o único tipo retornado */
@@ -189,7 +189,7 @@ QString BaseType::getTypeString(unsigned type_id)
if(type_id > types_count)
throw Exception(ERR_REF_TYPE_INV_INDEX,__PRETTY_FUNCTION__,__FILE__,__LINE__);
- return(tipos[type_id]);
+ return(type_list[type_id]);
}
void BaseType::setType(unsigned type_id,unsigned offset,unsigned count)
@@ -226,7 +226,7 @@ void BaseType::getTypes(QStringList &types,unsigned offset,unsigned count)
for(idx=offset; idx<total; idx++)
//Insere na lista os tipos que vao do offset ao total de tipos
- types.push_back(BaseType::tipos[idx]);
+ types.push_back(BaseType::type_list[idx]);
}
}
@@ -244,7 +244,7 @@ unsigned BaseType::getType(const QString &type_name,unsigned offset,unsigned cou
/*Verifica se o tipo passado pelo parametro está no conjunto de
tipos da classe */
for(idx=offset; idx<total && !found; idx++)
- found=(type_name==BaseType::tipos[idx]);
+ found=(type_name==BaseType::type_list[idx]);
if(found)
{ idx--; return(idx); }
@@ -255,7 +255,7 @@ unsigned BaseType::getType(const QString &type_name,unsigned offset,unsigned cou
QString BaseType::operator ~ (void)
{
- return(tipos[type_idx]);
+ return(type_list[type_idx]);
}
unsigned BaseType::operator ! (void)
@@ -286,14 +286,14 @@ bool BaseType::operator != (unsigned type_id)
/********************
* CLASSE: TipoAcao *
********************/
-ActionType::ActionType(unsigned tipo)
+ActionType::ActionType(unsigned type_id)
{
- (*this)=tipo;
+ (*this)=type_id;
}
-ActionType::ActionType(const QString &nome_tipo)
+ActionType::ActionType(const QString &type_name)
{
- (*this)=nome_tipo;
+ (*this)=type_name;
}
ActionType::ActionType(void)
@@ -301,288 +301,288 @@ ActionType::ActionType(void)
type_idx=offset;
}
-void ActionType::getTypes(QStringList &tipos)
+void ActionType::getTypes(QStringList &type_list)
{
- BaseType::getTypes(tipos,offset,types_count);
+ BaseType::getTypes(type_list,offset,types_count);
}
-unsigned ActionType::operator = (unsigned tipo)
+unsigned ActionType::operator = (unsigned type_id)
{
- BaseType::setType(tipo,offset,types_count);
+ BaseType::setType(type_id,offset,types_count);
return(type_idx);
}
-unsigned ActionType::operator = (const QString &nome_tipo)
+unsigned ActionType::operator = (const QString &type_name)
{
- unsigned idx_tipo;
+ unsigned type_idx;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ type_idx=BaseType::getType(type_name, offset, types_count);
+ BaseType::setType(type_idx,offset,types_count);
+ return(type_idx);
}
/**************************
* CLASSE: TipoRestricao *
**************************/
-TipoRestricao::TipoRestricao(unsigned tipo)
+ConstraintType::ConstraintType(unsigned type_id)
{
- (*this)=tipo;
+ (*this)=type_id;
}
-TipoRestricao::TipoRestricao(const QString &nome_tipo)
+ConstraintType::ConstraintType(const QString &type_name)
{
- (*this)=nome_tipo;
+ (*this)=type_name;
}
-TipoRestricao::TipoRestricao(void)
+ConstraintType::ConstraintType(void)
{
type_idx=offset;
}
-void TipoRestricao::getTypes(QStringList &tipos)
+void ConstraintType::getTypes(QStringList &type_list)
{
- BaseType::getTypes(tipos,offset,types_count);
+ BaseType::getTypes(type_list,offset,types_count);
}
-unsigned TipoRestricao::operator = (unsigned tipo)
+unsigned ConstraintType::operator = (unsigned type_id)
{
- BaseType::setType(tipo,offset,types_count);
+ BaseType::setType(type_id,offset,types_count);
return(type_idx);
}
-unsigned TipoRestricao::operator = (const QString &nome_tipo)
+unsigned ConstraintType::operator = (const QString &type_name)
{
- unsigned idx_tipo;
+ unsigned type_id;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ type_id=BaseType::getType(type_name, offset, types_count);
+ BaseType::setType(type_id,offset,types_count);
+ return(type_id);
}
/**********************
* CLASSE: TipoEvento *
**********************/
-TipoEvento::TipoEvento(void)
+EventType::EventType(void)
{
type_idx=offset;
}
-TipoEvento::TipoEvento(const QString &nome_tipo)
+EventType::EventType(const QString &type_name)
{
- (*this)=nome_tipo;
+ (*this)=type_name;
}
-TipoEvento::TipoEvento(unsigned tipo)
+EventType::EventType(unsigned type_id)
{
- (*this)=tipo;
+ (*this)=type_id;
}
-void TipoEvento::getTypes(QStringList &tipos)
+void EventType::getTypes(QStringList &type_list)
{
- BaseType::getTypes(tipos,offset,types_count);
+ BaseType::getTypes(type_list,offset,types_count);
}
-unsigned TipoEvento::operator = (unsigned tipo)
+unsigned EventType::operator = (unsigned type_id)
{
- BaseType::setType(tipo,offset,types_count);
+ BaseType::setType(type_id,offset,types_count);
return(type_idx);
}
-unsigned TipoEvento::operator = (const QString &nome_tipo)
+unsigned EventType::operator = (const QString &type_name)
{
- unsigned idx_tipo;
+ unsigned type_id;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ type_id=BaseType::getType(type_name, offset, types_count);
+ BaseType::setType(type_id,offset,types_count);
+ return(type_id);
}
-bool TipoEvento::operator < (TipoEvento tipo) const
+bool EventType::operator < (EventType type) const
{
- return(type_idx < tipo.type_idx);
+ return(type_idx < type.type_idx);
}
-bool TipoEvento::operator < (unsigned idx) const
+bool EventType::operator < (unsigned type_id) const
{
- return(type_idx < idx);
+ return(type_idx < type_id);
}
/************************
* CLASSE: TipoExecucao *
************************/
-TipoExecucao::TipoExecucao(void)
+ExecutionType::ExecutionType(void)
{
type_idx=offset;
}
-TipoExecucao::TipoExecucao(unsigned tipo)
+ExecutionType::ExecutionType(unsigned type_id)
{
- (*this)=tipo;
+ (*this)=type_id;
}
-TipoExecucao::TipoExecucao(const QString &nome_tipo)
+ExecutionType::ExecutionType(const QString &type_name)
{
- (*this)=nome_tipo;
+ (*this)=type_name;
}
-void TipoExecucao::getTypes(QStringList &tipos)
+void ExecutionType::getTypes(QStringList &type_list)
{
- BaseType::getTypes(tipos,offset,types_count);
+ BaseType::getTypes(type_list,offset,types_count);
}
-unsigned TipoExecucao::operator = (unsigned tipo)
+unsigned ExecutionType::operator = (unsigned type_id)
{
- BaseType::setType(tipo,offset,types_count);
+ BaseType::setType(type_id,offset,types_count);
return(type_idx);
}
-unsigned TipoExecucao::operator = (const QString &nome_tipo)
+unsigned ExecutionType::operator = (const QString &type_name)
{
- unsigned idx_tipo;
+ unsigned type_id;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ type_id=BaseType::getType(type_name, offset, types_count);
+ BaseType::setType(type_id,offset,types_count);
+ return(type_id);
}
/**********************
* CLASSE: TipoFuncao *
**********************/
-TipoFuncao::TipoFuncao(unsigned tipo)
+FunctionType::FunctionType(unsigned type_id)
{
- (*this)=tipo;
+ (*this)=type_id;
}
-TipoFuncao::TipoFuncao(void)
+FunctionType::FunctionType(void)
{
type_idx=offset;
}
-TipoFuncao::TipoFuncao(const QString &nome_tipo)
+FunctionType::FunctionType(const QString &type_name)
{
- (*this)=nome_tipo;
+ (*this)=type_name;
}
-void TipoFuncao::getTypes(QStringList &tipos)
+void FunctionType::getTypes(QStringList &tipos)
{
BaseType::getTypes(tipos,offset,types_count);
}
-unsigned TipoFuncao::operator = (unsigned tipo)
+unsigned FunctionType::operator = (unsigned type_id)
{
- BaseType::setType(tipo,offset,types_count);
+ BaseType::setType(type_id,offset,types_count);
return(type_idx);
}
-unsigned TipoFuncao::operator = (const QString &nome_tipo)
+unsigned FunctionType::operator = (const QString &type_name)
{
- unsigned idx_tipo;
+ unsigned type_id;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ type_id=BaseType::getType(type_name, offset, types_count);
+ BaseType::setType(type_id,offset,types_count);
+ return(type_id);
}
/**********************
* CLASSE: TipoIndexacao *
**********************/
-TipoIndexacao::TipoIndexacao(unsigned tipo)
+IndexingType::IndexingType(unsigned type_id)
{
- (*this)=tipo;
+ (*this)=type_id;
}
-TipoIndexacao::TipoIndexacao(void)
+IndexingType::IndexingType(void)
{
type_idx=offset;
}
-TipoIndexacao::TipoIndexacao(const QString &nome_tipo)
+IndexingType::IndexingType(const QString &type_name)
{
- (*this)=nome_tipo;
+ (*this)=type_name;
}
-void TipoIndexacao::getTypes(QStringList &tipos)
+void IndexingType::getTypes(QStringList &type_list)
{
- BaseType::getTypes(tipos,offset,types_count);
+ BaseType::getTypes(type_list,offset,types_count);
}
-unsigned TipoIndexacao::operator = (unsigned tipo)
+unsigned IndexingType::operator = (unsigned type_id)
{
- BaseType::setType(tipo,offset,types_count);
+ BaseType::setType(type_id,offset,types_count);
return(type_idx);
}
-unsigned TipoIndexacao::operator = (const QString &nome_tipo)
+unsigned IndexingType::operator = (const QString &type_name)
{
- unsigned idx_tipo;
+ unsigned type_id;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ type_id=BaseType::getType(type_name, offset, types_count);
+ BaseType::setType(type_id,offset,types_count);
+ return(type_id);
}
/**********************
* CLASSE: TipoIntervalo *
**********************/
-TipoIntervalo::TipoIntervalo(unsigned tipo)
+IntervalType::IntervalType(unsigned type_id)
{
- (*this)=tipo;
+ (*this)=type_id;
}
-TipoIntervalo::TipoIntervalo(void)
+IntervalType::IntervalType(void)
{
type_idx=BaseType::null;
}
-TipoIntervalo::TipoIntervalo(const QString &nome_tipo)
+IntervalType::IntervalType(const QString &type_name)
{
- (*this)=nome_tipo;
+ (*this)=type_name;
}
-void TipoIntervalo::getTypes(QStringList &tipos)
+void IntervalType::getTypes(QStringList &type_list)
{
- BaseType::getTypes(tipos,offset,types_count);
+ BaseType::getTypes(type_list,offset,types_count);
}
-unsigned TipoIntervalo::operator = (unsigned tipo)
+unsigned IntervalType::operator = (unsigned type_id)
{
- BaseType::setType(tipo,offset,types_count);
+ BaseType::setType(type_id,offset,types_count);
return(type_idx);
}
-unsigned TipoIntervalo::operator = (const QString &nome_tipo)
+unsigned IntervalType::operator = (const QString &type_name)
{
- unsigned idx_tipo;
+ unsigned type_id;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ type_id=BaseType::getType(type_name, offset, types_count);
+ BaseType::setType(type_id,offset,types_count);
+ return(type_id);
}
/************************
* CLASSE: TipoEspacial *
************************/
-TipoEspacial::TipoEspacial(const QString &nome_tipo, unsigned variacao)
+SpatialType::SpatialType(const QString &type_name, unsigned variation_id)
{
- BaseType::setType(BaseType::getType(nome_tipo, offset, types_count),
+ BaseType::setType(BaseType::getType(type_name, offset, types_count),
offset, types_count);
- definirVariacao(variacao);
+ setVariation(variation_id);
}
-TipoEspacial::TipoEspacial(unsigned tipo, unsigned variacao)
+SpatialType::SpatialType(unsigned type_id, unsigned var_id)
{
- BaseType::setType(tipo,offset,types_count);
- definirVariacao(variacao);
+ BaseType::setType(type_id,offset,types_count);
+ setVariation(var_id);
}
-TipoEspacial::TipoEspacial(void)
+SpatialType::SpatialType(void)
{
type_idx=point;
variacao=no_var;
}
-void TipoEspacial::definirVariacao(unsigned var)
+void SpatialType::setVariation(unsigned var)
{
if(var > var_zm)
variacao=var_zm;
@@ -590,17 +590,17 @@ void TipoEspacial::definirVariacao(unsigned var)
variacao=var;
}
-unsigned TipoEspacial::obterVariacao(void)
+unsigned SpatialType::getVariation(void)
{
return(variacao);
}
-void TipoEspacial::getTypes(QStringList &tipos)
+void SpatialType::getTypes(QStringList &type_list)
{
- BaseType::getTypes(tipos,offset,types_count);
+ BaseType::getTypes(type_list,offset,types_count);
}
-QString TipoEspacial::operator * (void)
+QString SpatialType::operator * (void)
{
QString var_str;
@@ -613,14 +613,14 @@ QString TipoEspacial::operator * (void)
}
//Atualmente o PostGiS aceita somente SRID = 4326 (Vide documentação Postgis 2.0)
- return(QString("(%1%2, 4326)").arg(tipos[type_idx]).arg(var_str));
+ return(QString("(%1%2, 4326)").arg(type_list[type_idx]).arg(var_str));
}
/*********************
* CLASSE: TipoPgSQL *
*********************/
//Inicializando a lista estática da classe
-vector<ConfigTipoUsuario> TipoPgSQL::tipos_usr;
+vector<UserTypeConfig> TipoPgSQL::tipos_usr;
TipoPgSQL::TipoPgSQL(void)
{
@@ -649,7 +649,7 @@ TipoPgSQL::TipoPgSQL(void *ptipo)
com_timezone=false;
}
-TipoPgSQL::TipoPgSQL(void *ptipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, TipoIntervalo tipo_interv, TipoEspacial tipo_esp)
+TipoPgSQL::TipoPgSQL(void *ptipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, IntervalType tipo_interv, SpatialType tipo_esp)
{
(*this) << ptipo;
definirComprimento(comprimento);
@@ -660,7 +660,7 @@ TipoPgSQL::TipoPgSQL(void *ptipo, unsigned comprimento, unsigned dimensao, int p
definirTipoEspacial(tipo_esp);
}
-TipoPgSQL::TipoPgSQL(const QString &tipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, TipoIntervalo tipo_interv, TipoEspacial tipo_esp)
+TipoPgSQL::TipoPgSQL(const QString &tipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, IntervalType tipo_interv, SpatialType tipo_esp)
{
(*this)=tipo;
definirComprimento(comprimento);
@@ -671,7 +671,7 @@ TipoPgSQL::TipoPgSQL(const QString &tipo, unsigned comprimento, unsigned dimensa
definirTipoEspacial(tipo_esp);
}
-TipoPgSQL::TipoPgSQL(unsigned idx_tipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, TipoIntervalo tipo_interv, TipoEspacial tipo_esp)
+TipoPgSQL::TipoPgSQL(unsigned idx_tipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, IntervalType tipo_interv, SpatialType tipo_esp)
{
(*this)=idx_tipo;
definirComprimento(comprimento);
@@ -695,7 +695,7 @@ void TipoPgSQL::getTypes(QStringList &tipos, bool tipo_oid, bool pseudos)
if(idx<ini_oid ||
(tipo_oid && idx>=ini_oid && idx<=fim_oid) ||
(pseudos && idx>=ini_pseudo && idx<=fim_pseudo))
- tipos.push_back(BaseType::tipos[idx]);
+ tipos.push_back(BaseType::type_list[idx]);
}
}
@@ -735,7 +735,7 @@ unsigned TipoPgSQL::operator = (const QString &nome_tipo)
void *TipoPgSQL::obterRefTipoUsuario(void)
{
if(this->tipoUsuario())
- return(tipos_usr[this->type_idx - (fim_pseudo + 1)].ptipo);
+ return(tipos_usr[this->type_idx - (fim_pseudo + 1)].ptype);
else
return(NULL);
}
@@ -743,7 +743,7 @@ void *TipoPgSQL::obterRefTipoUsuario(void)
unsigned TipoPgSQL::obterConfTipoUsuario(void)
{
if(this->tipoUsuario())
- return(tipos_usr[this->type_idx - (fim_pseudo + 1)].conf_tipo);
+ return(tipos_usr[this->type_idx - (fim_pseudo + 1)].type_conf);
else
return(0);
}
@@ -763,7 +763,7 @@ bool TipoPgSQL::operator == (const QString &nome_tipo)
/*Verifica se o tipo passado pelo parametro está no conjunto de
tipos da classe */
for(idx=offset; idx<total && !enc; idx++)
- enc=(nome_tipo==BaseType::tipos[idx]);
+ enc=(nome_tipo==BaseType::type_list[idx]);
if(enc) idx--;
@@ -798,12 +798,12 @@ bool TipoPgSQL::operator == (void *ptipo)
return(static_cast<int>(type_idx) == idx);
}
-TipoIntervalo TipoPgSQL::obterTipoIntervalo(void)
+IntervalType TipoPgSQL::obterTipoIntervalo(void)
{
return(tipo_intervalo);
}
-TipoEspacial TipoPgSQL::obterTipoEspacial(void)
+SpatialType TipoPgSQL::obterTipoEspacial(void)
{
return(tipo_espacial);
}
@@ -831,12 +831,12 @@ unsigned TipoPgSQL::operator << (void *ptipo)
return(type_idx);
}
-void TipoPgSQL::definirTipoIntervalo(TipoIntervalo tipo_interv)
+void TipoPgSQL::definirTipoIntervalo(IntervalType tipo_interv)
{
tipo_intervalo=tipo_interv;
}
-void TipoPgSQL::definirTipoEspacial(TipoEspacial tipo_esp)
+void TipoPgSQL::definirTipoEspacial(SpatialType tipo_esp)
{
tipo_espacial=tipo_esp;
}
@@ -876,18 +876,18 @@ void TipoPgSQL::definirTipoUsuario(void *ptipo)
void TipoPgSQL::adicionarTipoUsuario(const QString &nome, void *ptipo, void *pmodelo, unsigned conf_tipo_usr)
{
if(nome!="" && ptipo && pmodelo &&
- (conf_tipo_usr==ConfigTipoUsuario::TIPO_DOMINIO ||
- conf_tipo_usr==ConfigTipoUsuario::TIPO_SEQUENCIA ||
- conf_tipo_usr==ConfigTipoUsuario::TIPO_TABELA ||
- conf_tipo_usr==ConfigTipoUsuario::TIPO_BASE) &&
+ (conf_tipo_usr==UserTypeConfig::DOMAIN_TYPE ||
+ conf_tipo_usr==UserTypeConfig::SEQUENCE_TYPE ||
+ conf_tipo_usr==UserTypeConfig::TABLE_TYPE ||
+ conf_tipo_usr==UserTypeConfig::BASE_TYPE) &&
obterIndiceTipoUsuario(nome,ptipo,pmodelo)==0)
{
- ConfigTipoUsuario cfg;
+ UserTypeConfig cfg;
- cfg.nome=nome;
- cfg.ptipo=ptipo;
- cfg.pmodelo=pmodelo;
- cfg.conf_tipo=conf_tipo_usr;
+ cfg.name=nome;
+ cfg.ptype=ptipo;
+ cfg.pmodel=pmodelo;
+ cfg.type_conf=conf_tipo_usr;
TipoPgSQL::tipos_usr.push_back(cfg);
}
}
@@ -897,15 +897,15 @@ void TipoPgSQL::removerTipoUsuario(const QString &nome, void *ptipo)
if(TipoPgSQL::tipos_usr.size() > 0 &&
nome!="" && ptipo)
{
- ConfigTipoUsuario cfg;
- vector<ConfigTipoUsuario>::iterator itr, itr_end;
+ UserTypeConfig cfg;
+ vector<UserTypeConfig>::iterator itr, itr_end;
itr=TipoPgSQL::tipos_usr.begin();
itr_end=TipoPgSQL::tipos_usr.end();
while(itr!=itr_end)
{
- if(itr->nome==nome && itr->ptipo==ptipo) break;
+ if(itr->name==nome && itr->ptype==ptipo) break;
else itr++;
}
@@ -919,16 +919,16 @@ void TipoPgSQL::renomearTipoUsuario(const QString &nome, void *ptipo,const QStri
if(TipoPgSQL::tipos_usr.size() > 0 &&
nome!="" && ptipo && nome!=novo_nome)
{
- vector<ConfigTipoUsuario>::iterator itr, itr_end;
+ vector<UserTypeConfig>::iterator itr, itr_end;
itr=TipoPgSQL::tipos_usr.begin();
itr_end=TipoPgSQL::tipos_usr.end();
while(itr!=itr_end)
{
- if(itr->nome==nome && itr->ptipo==ptipo)
+ if(itr->name==nome && itr->ptype==ptipo)
{
- itr->nome=novo_nome;
+ itr->name=novo_nome;
break;
}
itr++;
@@ -945,7 +945,7 @@ unsigned TipoPgSQL::obterIndiceTipoUsuario(const QString &nome, void *ptipo, voi
{
if(TipoPgSQL::tipos_usr.size() > 0 && (nome!="" || ptipo))
{
- vector<ConfigTipoUsuario>::iterator itr, itr_end;
+ vector<UserTypeConfig>::iterator itr, itr_end;
int idx=0;
itr=TipoPgSQL::tipos_usr.begin();
@@ -953,8 +953,8 @@ unsigned TipoPgSQL::obterIndiceTipoUsuario(const QString &nome, void *ptipo, voi
while(itr!=itr_end)
{
- if(((nome!="" && itr->nome==nome) || (ptipo && itr->ptipo==ptipo)) &&
- ((pmodelo && itr->pmodelo==pmodelo) || !pmodelo))
+ if(((nome!="" && itr->name==nome) || (ptipo && itr->ptype==ptipo)) &&
+ ((pmodelo && itr->pmodel==pmodelo) || !pmodelo))
break;
idx++;
@@ -983,7 +983,7 @@ QString TipoPgSQL::getNameTipoUsuario(unsigned idx)
if(TipoPgSQL::tipos_usr.size() > 0 &&
(idx >= lim1 && idx < lim2))
- return(TipoPgSQL::tipos_usr[idx - lim1].nome);
+ return(TipoPgSQL::tipos_usr[idx - lim1].name);
else
return("");
}
@@ -998,9 +998,9 @@ void TipoPgSQL::obterTiposUsuario(QStringList &tipos, void *pmodelo, unsigned in
for(idx=0; idx < total; idx++)
{
//Só obtem os tipos definidos pelo usuário do modelo especificado
- if(tipos_usr[idx].pmodelo==pmodelo &&
- ((inc_tipos_usr & tipos_usr[idx].conf_tipo) == tipos_usr[idx].conf_tipo))
- tipos.push_back(tipos_usr[idx].nome);
+ if(tipos_usr[idx].pmodel==pmodelo &&
+ ((inc_tipos_usr & tipos_usr[idx].type_conf) == tipos_usr[idx].type_conf))
+ tipos.push_back(tipos_usr[idx].name);
}
}
@@ -1014,18 +1014,18 @@ void TipoPgSQL::obterTiposUsuario(vector<void *> &ptipos, void *pmodelo, unsigne
for(idx=0; idx < total; idx++)
{
//Só obtem os tipos definidos pelo usuário do modelo especificado
- if(tipos_usr[idx].pmodelo==pmodelo &&
- ((inc_tipos_usr & tipos_usr[idx].conf_tipo) == tipos_usr[idx].conf_tipo))
- ptipos.push_back(tipos_usr[idx].ptipo);
+ if(tipos_usr[idx].pmodel==pmodelo &&
+ ((inc_tipos_usr & tipos_usr[idx].type_conf) == tipos_usr[idx].type_conf))
+ ptipos.push_back(tipos_usr[idx].ptype);
}
}
QString TipoPgSQL::operator ~ (void)
{
if(type_idx >= fim_pseudo + 1)//offset + qtd_tipos)
- return(tipos_usr[type_idx - (fim_pseudo + 1)].nome);
+ return(tipos_usr[type_idx - (fim_pseudo + 1)].name);
else
- return(BaseType::tipos[type_idx]);
+ return(BaseType::type_list[type_idx]);
}
bool TipoPgSQL::tipoArray(void)
@@ -1040,18 +1040,18 @@ bool TipoPgSQL::tipoUsuario(void)
bool TipoPgSQL::tipoCompVariavel(void )
{
-return(tipos[this->type_idx]=="numeric" || tipos[this->type_idx]=="decimal" ||
- tipos[this->type_idx]=="character varying" || tipos[this->type_idx]=="varchar" ||
- tipos[this->type_idx]=="character" || tipos[this->type_idx]=="char" ||
- tipos[this->type_idx]=="bit" || tipos[this->type_idx]=="bit varying" ||
- tipos[this->type_idx]=="varbit");
+return(type_list[this->type_idx]=="numeric" || type_list[this->type_idx]=="decimal" ||
+ type_list[this->type_idx]=="character varying" || type_list[this->type_idx]=="varchar" ||
+ type_list[this->type_idx]=="character" || type_list[this->type_idx]=="char" ||
+ type_list[this->type_idx]=="bit" || type_list[this->type_idx]=="bit varying" ||
+ type_list[this->type_idx]=="varbit");
}
bool TipoPgSQL::tipoAceitaPrecisao(void )
{
- return(tipos[this->type_idx]=="numeric" || tipos[this->type_idx]=="decimal" ||
- tipos[this->type_idx]=="time" || tipos[this->type_idx]=="timestamp" ||
- tipos[this->type_idx]=="interval");
+ return(type_list[this->type_idx]=="numeric" || type_list[this->type_idx]=="decimal" ||
+ type_list[this->type_idx]=="time" || type_list[this->type_idx]=="timestamp" ||
+ type_list[this->type_idx]=="interval");
}
void TipoPgSQL::definirDimensao(unsigned dim)
@@ -1059,8 +1059,8 @@ void TipoPgSQL::definirDimensao(unsigned dim)
if(dim > 0 && this->tipoUsuario())
{
int idx=obterIndiceTipoUsuario(~(*this), NULL);
- if(tipos_usr[idx].conf_tipo==ConfigTipoUsuario::TIPO_DOMINIO ||
- tipos_usr[idx].conf_tipo==ConfigTipoUsuario::TIPO_SEQUENCIA)
+ if(tipos_usr[idx].type_conf==UserTypeConfig::DOMAIN_TYPE ||
+ tipos_usr[idx].type_conf==UserTypeConfig::SEQUENCE_TYPE)
throw Exception(ERR_ASG_INV_DOMAIN_ARRAY,__PRETTY_FUNCTION__,__FILE__,__LINE__);
}
@@ -1081,12 +1081,12 @@ void TipoPgSQL::definirComprimento(unsigned comp)
void TipoPgSQL::definirPrecisao(int prec)
{
//Caso o usuário tente definir uma precisao maior que o comprimento do tipo
- if(((BaseType::tipos[type_idx]=="numeric" ||
- BaseType::tipos[type_idx]=="decimal") && prec > static_cast<int>(comprimento)))
+ if(((BaseType::type_list[type_idx]=="numeric" ||
+ BaseType::type_list[type_idx]=="decimal") && prec > static_cast<int>(comprimento)))
throw Exception(ERR_ASG_INV_PRECISION,__PRETTY_FUNCTION__,__FILE__,__LINE__);
- else if(((BaseType::tipos[type_idx]=="time" ||
- BaseType::tipos[type_idx]=="timestamp" ||
- BaseType::tipos[type_idx]=="interval") && prec > 6))
+ else if(((BaseType::type_list[type_idx]=="time" ||
+ BaseType::type_list[type_idx]=="timestamp" ||
+ BaseType::type_list[type_idx]=="interval") && prec > 6))
throw Exception(ERR_ASG_INV_PREC_TIMESTAMP,__PRETTY_FUNCTION__,__FILE__,__LINE__);
else
//Define a precisão do tipo da coluna
@@ -1142,7 +1142,7 @@ QString TipoPgSQL::obterDefinicaoObjeto(unsigned tipo_def,QString tipo_ref)
if(!tipoUsuario() && tipo_espacial != BaseType::null)
{
atributos[ParsersAttributes::SPATIAL_TYPE]=(~tipo_espacial);
- atributos[ParsersAttributes::VARIATION]=QString("%1").arg(tipo_espacial.obterVariacao());
+ atributos[ParsersAttributes::VARIATION]=QString("%1").arg(tipo_espacial.getVariation());
}
if(com_timezone)
@@ -1168,10 +1168,10 @@ QString TipoPgSQL::operator * (void)
A sintaxe desses tipos se altera ficando na forma TIPO(COMPRIMENTO,PRECISÃO).*/
if((tipo=="numeric" || tipo=="decimal") && precisao>=0 &&
precisao<=static_cast<int>(comprimento))
- aux=QString("%1(%2,%3)").arg(BaseType::tipos[type_idx]).arg(comprimento).arg(precisao);
+ aux=QString("%1(%2,%3)").arg(BaseType::type_list[type_idx]).arg(comprimento).arg(precisao);
/* Trantado o caso dos tipos que necessitam apenas do comprimento */
else
- aux=QString("%1(%2)").arg(BaseType::tipos[type_idx]).arg(comprimento);
+ aux=QString("%1(%2)").arg(BaseType::type_list[type_idx]).arg(comprimento);
tipo_fmt=aux;
}
@@ -1181,7 +1181,7 @@ QString TipoPgSQL::operator * (void)
[TIME|TIMESTAMP] (PRECISÃO) [WITH|WITHOUT] TIMEZONE */
if(tipo!="interval")
{
- aux=BaseType::tipos[type_idx];
+ aux=BaseType::type_list[type_idx];
if(precisao >= 0)
aux+=QString("(%1)").arg(precisao);
@@ -1195,7 +1195,7 @@ QString TipoPgSQL::operator * (void)
INTERVAL [TIPO_INTERVALO](PRECISÃO) */
else
{
- aux=BaseType::tipos[type_idx];
+ aux=BaseType::type_list[type_idx];
if(tipo_intervalo!=BaseType::null)
aux+=QString("[%1]").arg(~tipo_intervalo);
@@ -1381,7 +1381,7 @@ bool TipoCodificacao::operator == (const QString &nome_tipo)
/*Verifica se o tipo passado pelo parametro está no conjunto de
tipos da classe */
for(idx=offset; idx<total && !enc; idx++)
- enc=(nome_tipo==BaseType::tipos[idx]);
+ enc=(nome_tipo==BaseType::type_list[idx]);
if(enc) idx--;
@@ -1447,7 +1447,7 @@ bool TipoArmazenamento::operator == (const QString &nome_tipo)
/*Verifica se o tipo passado pelo parametro está no conjunto de
tipos da classe */
for(idx=offset; idx<total && !enc; idx++)
- enc=(nome_tipo==BaseType::tipos[idx]);
+ enc=(nome_tipo==BaseType::type_list[idx]);
if(enc) idx--;
View
198 libpgmodeler/src/pgsqltypes.h
@@ -34,7 +34,7 @@ class BaseType{
static const unsigned types_count=189;
protected:
- static QString tipos[types_count];
+ static QString type_list[types_count];
unsigned type_idx;
/* Define um valor ao tipo de dado (o código do tipo deve estar
@@ -83,20 +83,19 @@ class ActionType: public BaseType{
static const unsigned set_null=offset+3;
static const unsigned set_default=offset+4;
- ActionType(const QString &nome_tipo);
- ActionType(unsigned tipo);
+ ActionType(const QString &type_name);
+ ActionType(unsigned type_id);
ActionType(void);
- //~TipoAcao(void){};
//Obtém todos os tipos válidos da classe e guarda em uma lista
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
//Atribui um tipo a instancia this
- unsigned operator = (unsigned tipo);
- unsigned operator = (const QString &nome_tipo);
+ unsigned operator = (unsigned type_id);
+ unsigned operator = (const QString &type_name);
};
-class TipoRestricao: public BaseType{
+class ConstraintType: public BaseType{
private:
static const unsigned offset=6;
static const unsigned types_count=4;
@@ -107,17 +106,16 @@ class TipoRestricao: public BaseType{
static const unsigned check=offset+2;
static const unsigned unique=offset+3;
- TipoRestricao(const QString &nome_tipo);
- TipoRestricao(unsigned tipo);
- TipoRestricao(void);
- //~TipoRestricao(void){};
+ ConstraintType(const QString &type_name);
+ ConstraintType(unsigned type_id);
+ ConstraintType(void);
- static void getTypes(QStringList &tipos);
- unsigned operator = (unsigned tipo);
- unsigned operator = (const QString &nome_tipo);
+ static void getTypes(QStringList &type_list);
+ unsigned operator = (unsigned type_id);
+ unsigned operator = (const QString &type_name);
};
-class TipoEvento: public BaseType{
+class EventType: public BaseType{
private:
static const unsigned offset=10;
static const unsigned types_count=5;
@@ -129,22 +127,21 @@ class TipoEvento: public BaseType{
static const unsigned on_update=offset+3;
static const unsigned on_truncate=offset+4;
- TipoEvento(const QString &nome_tipo);
- TipoEvento(unsigned tipo);
- TipoEvento(void);
- //~TipoEvento(void){};
+ EventType(const QString &type_name);
+ EventType(unsigned type_id);
+ EventType(void);
- static void getTypes(QStringList &tipos);
- unsigned operator = (unsigned tipo);
- unsigned operator = (const QString &nome_tipo);
+ static void getTypes(QStringList &type_list);
+ unsigned operator = (unsigned type_id);
+ unsigned operator = (const QString &type_name);
/* These two operators where created to permit the use the
class TipoEvento on STL containers (specially maps) */
- bool operator < (TipoEvento tipo) const;
- bool operator < (unsigned type_idx) const;
+ bool operator < (EventType type) const;
+ bool operator < (unsigned type_id) const;
};
-class TipoExecucao: public BaseType{
+class ExecutionType: public BaseType{
private:
static const unsigned offset=15;
static const unsigned types_count=2;
@@ -153,37 +150,35 @@ class TipoExecucao: public BaseType{
static const unsigned also=offset;
static const unsigned instead=offset+1;
- TipoExecucao(const QString &nome_tipo);
- TipoExecucao(unsigned tipo);
- TipoExecucao(void);
- //~TipoExecucao(void){};
+ ExecutionType(const QString &type_name);
+ ExecutionType(unsigned type_id);
+ ExecutionType(void);
- static void getTypes(QStringList&tipos);
- unsigned operator = (unsigned tipo);
- unsigned operator = (const QString &nome_tipo);
+ static void getTypes(QStringList&type_list);
+ unsigned operator = (unsigned type_id);
+ unsigned operator = (const QString &type_name);
};
-class TipoFuncao: public BaseType{
+class FunctionType: public BaseType{
private:
static const unsigned offset=17;
static const unsigned types_count=3;
public:
- static const unsigned volatil=offset;
- static const unsigned estavel=offset+1;
- static const unsigned imutavel=offset+2;
+ static const unsigned _volatile_=offset;
+ static const unsigned stable=offset+1;
+ static const unsigned immutable=offset+2;
- TipoFuncao(const QString &nome_tipo);
- TipoFuncao(unsigned tipo);
- TipoFuncao(void);
-// ~TipoFuncao(void){};
+ FunctionType(const QString &type_name);
+ FunctionType(unsigned type_id);
+ FunctionType(void);
- static void getTypes(QStringList &tipos);
- unsigned operator = (unsigned tipo);
- unsigned operator = (const QString &nome_tipo);
+ static void getTypes(QStringList &type_list);
+ unsigned operator = (unsigned type_id);
+ unsigned operator = (const QString &type_name);
};
-class TipoIndexacao: public BaseType{
+class IndexingType: public BaseType{
private:
static const unsigned offset=20;
static const unsigned types_count=5;
@@ -195,17 +190,16 @@ class TipoIndexacao: public BaseType{
static const unsigned hash=offset+3;
static const unsigned gin=offset+4;
- TipoIndexacao(const QString &nome_tipo);
- TipoIndexacao(unsigned tipo);
- TipoIndexacao(void);
-// ~TipoIndexacao(void){};
+ IndexingType(const QString &type_name);
+ IndexingType(unsigned type_id);
+ IndexingType(void);
- static void getTypes(QStringList &tipos);
- unsigned operator = (unsigned tipo);
- unsigned operator = (const QString &nome_tipo);
+ static void getTypes(QStringList &type_list);
+ unsigned operator = (unsigned type_id);
+ unsigned operator = (const QString &type_name);
};
-class TipoIntervalo: public BaseType{
+class IntervalType: public BaseType{
private:
static const unsigned offset=91;
static const unsigned types_count=13;
@@ -225,16 +219,16 @@ class TipoIntervalo: public BaseType{
static const unsigned hour_to_second=offset+11;
static const unsigned minute_to_second=offset+12;
- TipoIntervalo(const QString &nome_tipo);
- TipoIntervalo(unsigned tipo);
- TipoIntervalo(void);
+ IntervalType(const QString &type_name);
+ IntervalType(unsigned type_id);
+ IntervalType(void);
- static void getTypes(QStringList &tipos);
- unsigned operator = (unsigned tipo);
- unsigned operator = (const QString &nome_tipo);
+ static void getTypes(QStringList &type_list);
+ unsigned operator = (unsigned type_id);
+ unsigned operator = (const QString &type_name);
};
-class TipoEspacial: public BaseType{
+class SpatialType: public BaseType{
private:
unsigned variacao;
static const unsigned offset=182;
@@ -254,14 +248,14 @@ class TipoEspacial: public BaseType{
static const unsigned multipolygon=offset+5;
static const unsigned geometrycollection=offset+6;
- TipoEspacial(const QString &nome_tipo, unsigned variacao=TipoEspacial::no_var);
- TipoEspacial(unsigned tipo, unsigned variacao=TipoEspacial::no_var);
- TipoEspacial(void);
+ SpatialType(const QString &type_name, unsigned variation_id=SpatialType::no_var);
+ SpatialType(unsigned type_id, unsigned var_id=SpatialType::no_var);
+ SpatialType(void);
- void definirVariacao(unsigned var);
- unsigned obterVariacao(void);
+ void setVariation(unsigned var);
+ unsigned getVariation(void);
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
QString operator * (void);
};
@@ -270,30 +264,30 @@ class TipoEspacial: public BaseType{
entre tipos definidos pelo usuário e tipos internos
do PostgreSQL de forma transparente. Poderá (deverá?)
ser modificado em futuras versões do pgModeler. */
-class ConfigTipoUsuario {
+class UserTypeConfig {
protected:
//Ponteiro para a instância do tipo definido pelo usuário
- void *ptipo;
+ void *ptype;
//Ponteiro para a instância do modelo ao qual o tipo pertence
- void *pmodelo;
+ void *pmodel;
//Nome do tipo definido pelo usário
- QString nome;
+ QString name;
- unsigned conf_tipo;
+ unsigned type_conf;
public:
- static const unsigned TIPO_BASE=1,
- TIPO_DOMINIO=2,
- TIPO_TABELA=4,
- TIPO_SEQUENCIA=8,
+ static const unsigned BASE_TYPE=1,
+ DOMAIN_TYPE=2,
+ TABLE_TYPE=4,
+ SEQUENCE_TYPE=8,
/* Esta constante é usada somente para referenciar todos os tipos de uma vez,
é não deve ser usado para definir um tipo de configuração */
- TIPO_USR_TODOS=15;
+ ALL_USER_TYPES=15;
- ConfigTipoUsuario(void)
- { nome=""; ptipo=NULL; pmodelo=NULL; conf_tipo=TIPO_BASE; }
+ UserTypeConfig(void)
+ { name=""; ptype=NULL; pmodel=NULL; type_conf=BASE_TYPE; }
friend class TipoPgSQL;
};
@@ -315,7 +309,7 @@ class TipoPgSQL: public BaseType{
e Dominio têm acesso a esta lista através de métodos de acesso. Esta classe é a
responsável por inserir e remover itens desta lista ao ser criado um novo
tipo ou excluido um já existente. */
- static vector<ConfigTipoUsuario> tipos_usr; //Lista de tipos de dados definidos pelo usuário
+ static vector<UserTypeConfig> tipos_usr; //Lista de tipos de dados definidos pelo usuário
//Dimensão do tipo caso ele seja um array ( > 0 indica que o mesmo é um array)
unsigned dimensao,
@@ -332,10 +326,10 @@ class TipoPgSQL: public BaseType{
bool com_timezone;
//Tipo de intervalo de tempo usado pelo tipo de dado 'interval'
- TipoIntervalo tipo_intervalo;
+ IntervalType tipo_intervalo;
//Tipo espacial usado na criação de tipos do PostGiS
- TipoEspacial tipo_espacial;
+ SpatialType tipo_espacial;
protected:
/* Adiciona uma nova referência ao tipo definido pelo usuário
@@ -363,16 +357,16 @@ class TipoPgSQL: public BaseType{
TipoPgSQL(void *ptipo);
TipoPgSQL(const QString &tipo, unsigned comprimento,
unsigned dimensao, int precisao,
- bool com_timezone, TipoIntervalo tipo_interv,
- TipoEspacial tipo_esp);
+ bool com_timezone, IntervalType tipo_interv,
+ SpatialType tipo_esp);
TipoPgSQL(void *ptipo, unsigned comprimento,
unsigned dimensao, int precisao,
- bool com_timezone, TipoIntervalo tipo_interv,
- TipoEspacial tipo_esp);
+ bool com_timezone, IntervalType tipo_interv,
+ SpatialType tipo_esp);
TipoPgSQL(unsigned type_idx, unsigned comprimento,
unsigned dimensao, int precisao,
- bool com_timezone, TipoIntervalo tipo_interv,
- TipoEspacial tipo_esp);
+ bool com_timezone, IntervalType tipo_interv,
+ SpatialType tipo_esp);
/* Obtém o índice referente a um tipo definido pelo usuário.
Retorna 0 caso o tipo não exista na lista. */
@@ -380,22 +374,22 @@ class TipoPgSQL: public BaseType{
static unsigned obterIndiceTipoBase(const QString &nome);
//Obtém todos os tipos definidos pelo usuário
- static void obterTiposUsuario(QStringList &tipos, void *pmodelo, unsigned inc_tipos_usr);
+ static void obterTiposUsuario(QStringList &type_list, void *pmodelo, unsigned inc_tipos_usr);
static void obterTiposUsuario(vector<void *> &ptipos, void *pmodelo, unsigned inc_tipos_usr);
- static void getTypes(QStringList &tipos, bool tipo_oid=true, bool pseudos=true);
+ static void getTypes(QStringList &type_list, bool tipo_oid=true, bool pseudos=true);
void definirDimensao(unsigned dim);
void definirComprimento(unsigned comp);
void definirPrecisao(int prec);
void definirComTimezone(bool com_timezone);
- void definirTipoIntervalo(TipoIntervalo tipo_interv);
- void definirTipoEspacial(TipoEspacial tipo_espacial);
+ void definirTipoIntervalo(IntervalType tipo_interv);
+ void definirTipoEspacial(SpatialType tipo_espacial);
unsigned obterDimensao(void);
unsigned obterComprimento(void);
int obterPrecisao(void);
- TipoIntervalo obterTipoIntervalo(void);
- TipoEspacial obterTipoEspacial(void);
+ IntervalType obterTipoIntervalo(void);
+ SpatialType obterTipoEspacial(void);
bool comTimezone(void); //Retorna se o tipo considera timezone
bool pseudoTipo(void); //Retorna se o tipo é um pseudo-tipo
@@ -455,7 +449,7 @@ class TipoComportamento: public BaseType{
TipoComportamento(void);
// ~TipoRetorno(void){};
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
};
@@ -474,7 +468,7 @@ class TipoSeguranca: public BaseType{
TipoSeguranca(void);
// ~TipoSeguranca(void){};
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
};
@@ -497,7 +491,7 @@ class TipoLinguagem: public BaseType{
TipoLinguagem(void);
// ~TipoLinguagem(void){};
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
};
@@ -512,7 +506,7 @@ class TipoCodificacao: public BaseType{
TipoCodificacao(const QString &tipo);
// ~TipoCodificacao(void){};
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
bool operator == (const QString &nome_tipo);
@@ -536,7 +530,7 @@ class TipoArmazenamento: public BaseType{
TipoArmazenamento(const QString &tipo);
// ~TipoArmazenamento(void){};
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
bool operator == (const QString &nome_tipo);
@@ -560,7 +554,7 @@ class TipoComparacao: public BaseType{
TipoComparacao(void);
// ~TipoComparacao(void){};
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
};
@@ -579,7 +573,7 @@ class TipoPostergacao: public BaseType{
TipoPostergacao(void);
// ~TipoPostergacao(void){};
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
};
@@ -609,7 +603,7 @@ class TipoCategoria: public BaseType{
TipoCategoria(const QString &nome_tipo);
TipoCategoria(void);
- static void getTypes(QStringList &tipos);
+ static void getTypes(QStringList &type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
};
@@ -628,7 +622,7 @@ class TipoDisparo: public BaseType{
TipoDisparo(unsigned tipo);
TipoDisparo(void);
- static void getTypes(QStringList&tipos);
+ static void getTypes(QStringList&type_list);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
};
View
24 libpgmodeler/src/relationship.cpp
@@ -187,7 +187,7 @@ void Relationship::createSpecialPrimaryKey(void)
2) Use the same tablespace as the receiver table */
pk_special=new Constraint;
pk_special->setName(this->getName() + QString("_pk"));
- pk_special->setConstraintType(TipoRestricao::primary_key);
+ pk_special->setConstraintType(ConstraintType::primary_key);
pk_special->setAddedByLinking(true);
pk_special->setProtected(true);
pk_special->setTablespace(dynamic_cast<Tablespace *>(getReceiverTable()->getTablespace()));
@@ -347,7 +347,7 @@ void Relationship::addObject(TableObject *tab_obj, int obj_idx)
rest=dynamic_cast<Constraint *>(tab_obj);
//Raises an error if the user try to add as foreign key to relationship
- if(rest->getConstraintType()==TipoRestricao::foreign_key)
+ if(rest->getConstraintType()==ConstraintType::foreign_key)
throw Exception(ERR_ASG_FOREIGN_KEY_REL,__PRETTY_FUNCTION__,__FILE__,__LINE__);
rest->getCodeDefinition(SchemaParser::SQL_DEFINITION);
@@ -621,7 +621,7 @@ void Relationship::addConstraints(Tabela *dst_tab)
if(constr->getParentTable())
break;
- if(constr->getConstraintType()!=TipoRestricao::primary_key)
+ if(constr->getConstraintType()!=ConstraintType::primary_key)
{
i=1; aux[0]='\0';