Skip to content
Browse files

pgsqltypes refactoring checkpoint.

  • Loading branch information...
1 parent c0c7a41 commit eaa433b7cdbd3f621ffa87bf9c362a6225d6edfc @rkhaotix rkhaotix committed Dec 18, 2012
Showing with 489 additions and 495 deletions.
  1. +8 −8 libpgmodeler/src/aggregate.cpp
  2. +7 −7 libpgmodeler/src/aggregate.h
  3. +4 −4 libpgmodeler/src/cast.cpp
  4. +3 −3 libpgmodeler/src/cast.h
  5. +4 −4 libpgmodeler/src/column.cpp
  6. +3 −3 libpgmodeler/src/column.h
  7. +7 −7 libpgmodeler/src/domain.cpp
  8. +3 −3 libpgmodeler/src/domain.h
  9. +8 −8 libpgmodeler/src/function.cpp
  10. +6 −6 libpgmodeler/src/function.h
  11. +22 −22 libpgmodeler/src/modelobd.cpp
  12. +2 −2 libpgmodeler/src/modelobd.h
  13. +6 −6 libpgmodeler/src/operator.cpp
  14. +3 −3 libpgmodeler/src/operator.h
  15. +4 −4 libpgmodeler/src/operatorclass.cpp
  16. +3 −3 libpgmodeler/src/operatorclass.h
  17. +4 −4 libpgmodeler/src/operatorclasselement.cpp
  18. +3 −3 libpgmodeler/src/operatorclasselement.h
  19. +245 −252 libpgmodeler/src/pgsqltypes.cpp
  20. +66 −65 libpgmodeler/src/pgsqltypes.h
  21. +5 −5 libpgmodeler/src/relationship.cpp
  22. +3 −3 libpgmodeler/src/sequence.cpp
  23. +3 −3 libpgmodeler/src/tabela.cpp
  24. +20 −20 libpgmodeler/src/type.cpp
  25. +8 −8 libpgmodeler/src/type.h
  26. +1 −1 libpgmodeler_ui/src/classeoperadoreswidget.cpp
  27. +1 −1 libpgmodeler_ui/src/colunawidget.cpp
  28. +1 −1 libpgmodeler_ui/src/conversaotipowidget.cpp
  29. +1 −1 libpgmodeler_ui/src/dominiowidget.cpp
  30. +5 −5 libpgmodeler_ui/src/funcaoagregacaowidget.cpp
  31. +5 −5 libpgmodeler_ui/src/funcaowidget.cpp
  32. +1 −1 libpgmodeler_ui/src/objetobasewidget.h
  33. +1 −1 libpgmodeler_ui/src/operadorwidget.cpp
  34. +18 −18 libpgmodeler_ui/src/tipopgsqlwidget.cpp
  35. +3 −3 libpgmodeler_ui/src/tipopgsqlwidget.h
  36. +2 −2 libpgmodeler_ui/src/tipowidget.cpp
View
16 libpgmodeler/src/aggregate.cpp
@@ -64,7 +64,7 @@ bool Aggregate::isValidFunction(unsigned func_idx, Function *func)
else return(true);
}
-void Aggregate::setStateType(TipoPgSQL state_type)
+void Aggregate::setStateType(PgSQLType state_type)
{
this->state_type=state_type;
}
@@ -112,7 +112,7 @@ void Aggregate::setTypesAttribute(unsigned def_type)
str_types+=*(data_types[i]);
if(i < (count-1)) str_types+=",";
}
- else str_types+=data_types[i].obterDefinicaoObjeto(def_type);
+ else str_types+=data_types[i].getObjectDefinition(def_type);
}
/* Caso o usuário não especifique nenhum tipo de entrada para a função
@@ -124,7 +124,7 @@ void Aggregate::setTypesAttribute(unsigned def_type)
attributes[ParsersAttributes::TYPES]=str_types;
}
-void Aggregate::addDataType(TipoPgSQL type)
+void Aggregate::addDataType(PgSQLType type)
{
//Case the data type already exists in the aggregate raise an exception
if(isDataTypeExist(type))
@@ -151,9 +151,9 @@ void Aggregate::removeDataTypes(void)
data_types.clear();
}
-bool Aggregate::isDataTypeExist(TipoPgSQL type)
+bool Aggregate::isDataTypeExist(PgSQLType type)
{
- vector<TipoPgSQL>::iterator itr, itr_end;
+ vector<PgSQLType>::iterator itr, itr_end;
bool enc=false;
itr=data_types.begin();
@@ -182,7 +182,7 @@ Function *Aggregate::getFunction(unsigned func_idx)
return(functions[func_idx]);
}
-TipoPgSQL Aggregate::getStateType(void)
+PgSQLType Aggregate::getStateType(void)
{
return(state_type);
}
@@ -197,7 +197,7 @@ Operator *Aggregate::getSortOperator(void)
return(sort_operator);
}
-TipoPgSQL Aggregate::getDataType(unsigned type_idx)
+PgSQLType Aggregate::getDataType(unsigned type_idx)
{
//Raises an exception if the type index is out of bound
if(type_idx >= data_types.size())
@@ -248,7 +248,7 @@ QString Aggregate::getCodeDefinition(unsigned def_type)
if(def_type==SchemaParser::SQL_DEFINITION)
attributes[ParsersAttributes::STATE_TYPE]=*(state_type);
else
- attributes[ParsersAttributes::STATE_TYPE]=state_type.obterDefinicaoObjeto(def_type,ParsersAttributes::STATE_TYPE);
+ attributes[ParsersAttributes::STATE_TYPE]=state_type.getObjectDefinition(def_type,ParsersAttributes::STATE_TYPE);
return(BaseObject::__getCodeDefinition(def_type));
}
View
14 libpgmodeler/src/aggregate.h
@@ -37,15 +37,15 @@ class Aggregate: public BaseObject {
To declare an aggregate function which works with several
types in the old syntax, the only element of the list must
be of type 'any' */
- vector<TipoPgSQL> data_types;
+ vector<PgSQLType> data_types;
/* Function that defines the aggregate behavior
0 -> Final function
1 -> Transition function */
Function *functions[2];
//Data type used as aggregate's state
- TipoPgSQL state_type;
+ PgSQLType state_type;
//Initial condition for the aggregate
QString initial_condition;
@@ -70,7 +70,7 @@ class Aggregate: public BaseObject {
void setFunction(unsigned func_idx, Function *func);
//Defines the state data type of the aggregate
- void setStateType(TipoPgSQL state_type);
+ void setStateType(PgSQLType state_type);
//Defines the initial condition for the aggregate
void setInitialCondition(const QString &cond);
@@ -79,7 +79,7 @@ class Aggregate: public BaseObject {
void setSortOperator(Operator *sort_op);
//Adds a data type in the group that is accepted by the aggregate
- void addDataType(TipoPgSQL type);
+ void addDataType(PgSQLType type);
//Removes one aggregate accepted data type
void removeDataType(unsigned type_idx);
@@ -88,13 +88,13 @@ class Aggregate: public BaseObject {
void removeDataTypes(void);
//Checks whether the passed type exists in the aggregate's set of data types
- bool isDataTypeExist(TipoPgSQL type);
+ bool isDataTypeExist(PgSQLType type);
Function *getFunction(unsigned func_idx);
- TipoPgSQL getStateType(void);
+ PgSQLType getStateType(void);
QString getInitialCondition(void);
Operator *getSortOperator(void);
- TipoPgSQL getDataType(unsigned type_idx);
+ PgSQLType getDataType(unsigned type_idx);
unsigned getDataTypeCount(void);
//Returns the SQL / XML code definition for the aggregate
View
8 libpgmodeler/src/cast.cpp
@@ -13,7 +13,7 @@ Cast::Cast(void)
attributes[ParsersAttributes::IO_CAST]="";
}
-void Cast::setDataType(unsigned type_idx, TipoPgSQL type)
+void Cast::setDataType(unsigned type_idx, PgSQLType type)
{
//Check if the type index is valid
if(type_idx<=DST_TYPE)
@@ -104,7 +104,7 @@ void Cast::setCastFunction(Function *cast_func)
this->cast_function=cast_func;
}
-TipoPgSQL Cast::getDataType(unsigned type_idx)
+PgSQLType Cast::getDataType(unsigned type_idx)
{
if(type_idx<=DST_TYPE)
return(this->types[type_idx]);
@@ -136,8 +136,8 @@ QString Cast::getCodeDefinition(unsigned def_type)
}
else
{
- attributes[ParsersAttributes::SOURCE_TYPE]=types[SRC_TYPE].obterDefinicaoObjeto(def_type);
- attributes[ParsersAttributes::DEST_TYPE]=types[DST_TYPE].obterDefinicaoObjeto(def_type);
+ attributes[ParsersAttributes::SOURCE_TYPE]=types[SRC_TYPE].getObjectDefinition(def_type);
+ attributes[ParsersAttributes::DEST_TYPE]=types[DST_TYPE].getObjectDefinition(def_type);
}
if(cast_function)
View
6 libpgmodeler/src/cast.h
@@ -31,7 +31,7 @@ class Cast: public BaseObject {
/* Data types used on the cast:
0 -> Source data type
1 -> Destination data type */
- TipoPgSQL types[2];
+ PgSQLType types[2];
//Conversion type (ASSIGNMENT or IMPLICIT)
unsigned cast_type;
@@ -55,7 +55,7 @@ class Cast: public BaseObject {
/* Defines one of the data types envolved on the cast
(using constants SRC_TYPE | DST_TYPE) */
- void setDataType(unsigned type_idx, TipoPgSQL type);
+ void setDataType(unsigned type_idx, PgSQLType type);
//Defines the cast type (using constants ASSINGMENT | IMPLICIT)
void setCastType(unsigned cast_type);
@@ -69,7 +69,7 @@ class Cast: public BaseObject {
void setInOut(bool value);
//Returns one of the cast envolved data types
- TipoPgSQL getDataType(unsigned type_idx);
+ PgSQLType getDataType(unsigned type_idx);
//Returns the cast type
unsigned getCastType(void);
View
8 libpgmodeler/src/column.cpp
@@ -32,10 +32,10 @@ void Column::setName(const QString &name)
}
}
-void Column::setType(TipoPgSQL type)
+void Column::setType(PgSQLType type)
{
//An error is raised if the column receive a pseudo-type as data type.
- if(type.pseudoTipo())
+ if(type.isPseudoType())
throw Exception(ERR_ASG_PSDTYPE_COLUMN,__PRETTY_FUNCTION__,__FILE__,__LINE__);
else
this->type=type;
@@ -51,7 +51,7 @@ void Column::setNotNull(bool value)
not_null=value;
}
-TipoPgSQL Column::getType(void)
+PgSQLType Column::getType(void)
{
return(type);
}
@@ -87,7 +87,7 @@ QString Column::getCodeDefinition(unsigned def_type)
if(this->parent_table)
attributes[ParsersAttributes::TABLE]=this->parent_table->getName(true);
- attributes[ParsersAttributes::TYPE]=type.obterDefinicaoObjeto(def_type);
+ attributes[ParsersAttributes::TYPE]=type.getObjectDefinition(def_type);
attributes[ParsersAttributes::DEFAULT_VALUE]=default_value;
attributes[ParsersAttributes::NOT_NULL]=(!not_null ? "" : "1");
return(BaseObject::__getCodeDefinition(def_type));
View
6 libpgmodeler/src/column.h
@@ -35,7 +35,7 @@ class Column: public TableObject{
bool not_null;
//Data type of the column
- TipoPgSQL type;
+ PgSQLType type;
/* Default value of the column.
Note: The user must format the default value in
@@ -51,7 +51,7 @@ class Column: public TableObject{
void setNotNull(bool value);
//Defines the column data type
- void setType(TipoPgSQL type);
+ void setType(PgSQLType type);
/* Sets the default value of the column. Must be informed together with the value
the particularities of each type, such as quotation marks, hyphens, etc. */
@@ -70,7 +70,7 @@ class Column: public TableObject{
bool isNotNull(void);
//Returns the data type of the column
- TipoPgSQL getType(void);
+ PgSQLType getType(void);
//Returns the default value of the column
QString getDefaultValue(void);
View
14 libpgmodeler/src/domain.cpp
@@ -13,7 +13,7 @@ Domain::Domain(void)
Domain::~Domain(void)
{
- TipoPgSQL::removerTipoUsuario(this->getName(true), this);
+ PgSQLType::removeUserType(this->getName(true), this);
}
void Domain::setName(const QString &name)
@@ -25,7 +25,7 @@ void Domain::setName(const QString &name)
new_name=this->getName(true);
//Renames the PostgreSQL type represented by the domain
- TipoPgSQL::renomearTipoUsuario(prev_name, this, new_name);
+ PgSQLType::renameUserType(prev_name, this, new_name);
}
void Domain::setSchema(BaseObject *schema)
@@ -36,7 +36,7 @@ void Domain::setSchema(BaseObject *schema)
BaseObject::setSchema(schema);
//Renames the PostgreSQL type represented by the domain
- TipoPgSQL::renomearTipoUsuario(prev_name, this, this->getName(true));
+ PgSQLType::renameUserType(prev_name, this, this->getName(true));
}
void Domain::setConstraintName(const QString &constr_name)
@@ -63,7 +63,7 @@ void Domain::setNotNull(bool value)
not_null=value;
}
-void Domain::setType(TipoPgSQL type)
+void Domain::setType(PgSQLType type)
{
this->type=type;
}
@@ -88,7 +88,7 @@ bool Domain::isNotNull(void)
return(not_null);
}
-TipoPgSQL Domain::getType(void)
+PgSQLType Domain::getType(void)
{
return(type);
}
@@ -104,7 +104,7 @@ QString Domain::getCodeDefinition(unsigned def_type)
attributes[ParsersAttributes::TYPE]=(*type);
else
{
- attributes[ParsersAttributes::TYPE]=type.obterDefinicaoObjeto(def_type);
+ attributes[ParsersAttributes::TYPE]=type.getObjectDefinition(def_type);
}
return(BaseObject::__getCodeDefinition(def_type));
@@ -120,6 +120,6 @@ void Domain::operator = (Domain &domain)
this->not_null=domain.not_null;
this->default_value=domain.default_value;
this->type=domain.type;
- TipoPgSQL::renomearTipoUsuario(prev_name, this, this->getName(true));
+ PgSQLType::renameUserType(prev_name, this, this->getName(true));
}
View
6 libpgmodeler/src/domain.h
@@ -38,7 +38,7 @@ class Domain: public BaseObject{
bool not_null;
//Domain data type
- TipoPgSQL type;
+ PgSQLType type;
public:
Domain(void);
@@ -57,7 +57,7 @@ class Domain: public BaseObject{
void setNotNull(bool value);
//Defines the domain data type
- void setType(TipoPgSQL type);
+ void setType(PgSQLType type);
/* Overloaded BaseObject name definition method.
Updates the reference of the domain as a PostgreSQL data type */
@@ -72,7 +72,7 @@ class Domain: public BaseObject{
QString getExpression(void);
QString getDefaultValue(void);
bool isNotNull(void);
- TipoPgSQL getType(void);
+ PgSQLType getType(void);
//Returns the SQL / XML code definition for the domain
QString getCodeDefinition(unsigned tipo_def);
View
16 libpgmodeler/src/function.cpp
@@ -6,7 +6,7 @@ Parameter::Parameter(void)
is_in=is_out=false;
}
-void Parameter::setType(TipoPgSQL type)
+void Parameter::setType(PgSQLType type)
{
this->type=type;
}
@@ -50,7 +50,7 @@ QString Parameter::getCodeDefinition(unsigned def_type)
attributes[ParsersAttributes::PARAM_IN]=(is_in ? "1" : "");
attributes[ParsersAttributes::PARAM_OUT]=(is_out ? "1" : "");
attributes[ParsersAttributes::DEFAULT_VALUE]=default_value;
- attributes[ParsersAttributes::TYPE]=type.obterDefinicaoObjeto(def_type);
+ attributes[ParsersAttributes::TYPE]=type.getObjectDefinition(def_type);
return(BaseObject::__getCodeDefinition(def_type));
}
@@ -60,7 +60,7 @@ unsigned Function::function_id=40000;
Function::Function(void)
{
object_id=Function::function_id++;
- return_type=TipoPgSQL("void");
+ return_type=PgSQLType("void");
language=NULL;
returns_setof=false;
is_wnd_function=false;
@@ -129,7 +129,7 @@ void Function::addParameter(Parameter param)
createSignature();
}
-void Function::addReturnedTableColumn(const QString &name, TipoPgSQL type)
+void Function::addReturnedTableColumn(const QString &name, PgSQLType type)
{
//Raises an error if the column name is empty
if(name=="")
@@ -227,7 +227,7 @@ void Function::setSymbol(const QString &symbol)
this->symbol=symbol;
}
-void Function::setReturnType(TipoPgSQL type)
+void Function::setReturnType(PgSQLType type)
{
return_type=type;
}
@@ -279,7 +279,7 @@ void Function::setSourceCode(const QString &src_code)
this->source_code=src_code;
}
-TipoPgSQL Function::getReturnType(void)
+PgSQLType Function::getReturnType(void)
{
return(return_type);
}
@@ -383,7 +383,7 @@ void Function::removeReturnedTableColumns(void)
ret_table_columns.clear();
}
-void Function::removeParameter(const QString &name, TipoPgSQL type)
+void Function::removeParameter(const QString &name, PgSQLType type)
{
vector<Parameter>::iterator itr,itr_end;
@@ -473,7 +473,7 @@ QString Function::getCodeDefinition(unsigned def_type, bool reduced_form)
else
{
attributes[ParsersAttributes::LANGUAGE]=language->getCodeDefinition(def_type,true);
- attributes[ParsersAttributes::RETURN_TYPE]=return_type.obterDefinicaoObjeto(def_type);
+ attributes[ParsersAttributes::RETURN_TYPE]=return_type.getObjectDefinition(def_type);
}
setTableReturnTypeAttribute(def_type);
View
12 libpgmodeler/src/function.h
@@ -36,7 +36,7 @@ class Parameter: public Column {
public:
Parameter(void);
- void setType(TipoPgSQL type);
+ void setType(PgSQLType type);
void setIn(bool value);
void setOut(bool value);
@@ -86,7 +86,7 @@ class Function: public BaseObject {
FunctionType function_type;
//Function return type
- TipoPgSQL return_type;
+ PgSQLType return_type;
/* Stores the table columns returned by the clause RETURNS TABLE. This clause instead
of return a specific element returns a whole table. This structure is available
@@ -121,7 +121,7 @@ class Function: public BaseObject {
void addParameter(Parameter param);
//Adds a column to the function returned table
- void addReturnedTableColumn(const QString &name, TipoPgSQL type);
+ void addReturnedTableColumn(const QString &name, PgSQLType type);
//Defines the function source code (if its not use the C language)
void setSourceCode(const QString &src_code);
@@ -154,7 +154,7 @@ class Function: public BaseObject {
void setFunctionType(FunctionType func_type);
//Defines the function return type
- void setReturnType(TipoPgSQL type);
+ void setReturnType(PgSQLType type);
//Defines the security type of the function
void setSecurityType(TipoSeguranca sec_type);
@@ -199,7 +199,7 @@ class Function: public BaseObject {
FunctionType getFunctionType(void);
//Returns the function returned type
- TipoPgSQL getReturnType(void);
+ PgSQLType getReturnType(void);
//Returns the security type used by the function
TipoSeguranca getSecurityType(void);
@@ -211,7 +211,7 @@ class Function: public BaseObject {
unsigned getRowAmount(void);
//Removes a parameter using its name and type
- void removeParameter(const QString &name, TipoPgSQL type);
+ void removeParameter(const QString &name, PgSQLType type);
//Removes a parameter using its index
void removeParameter(unsigned param_idx);
View
44 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, UserTypeConfig::TABLE_TYPE);
+ PgSQLType::addUserType(tabela->getName(true), tabela, this, UserTypeConfig::TABLE_TYPE);
atualizarRelFkTabela(tabela);
}
@@ -800,7 +800,7 @@ void ModeloBD::removerTabela(Tabela *tabela, int idx_obj)
/* Ao ser removido do modelo a sequencia tem
seu nome removido da lista de tipos válidos do PostgreSQL */
- TipoPgSQL::removerTipoUsuario(tabela->getName(true), tabela);
+ PgSQLType::removeUserType(tabela->getName(true), tabela);
//Remove qualquer relacionamento gerado por chave estrangeira
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, UserTypeConfig::SEQUENCE_TYPE);
+ PgSQLType::addUserType(sequencia->getName(true), sequencia, this, UserTypeConfig::SEQUENCE_TYPE);
}
catch(Exception &e)
{
@@ -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, UserTypeConfig::DOMAIN_TYPE);
+ PgSQLType::addUserType(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, UserTypeConfig::BASE_TYPE);
+ PgSQLType::addUserType(tipo->getName(true), tipo, this, UserTypeConfig::BASE_TYPE);
}
catch(Exception &e)
{
@@ -2466,7 +2466,7 @@ void ModeloBD::removerTipoUsuario(BaseObject *objeto, int idx_obj)
__removerObjeto(objeto, idx_obj);
/* Ao ser removido do modelo o objeto (tipo ou domínio) classe tem
seu nome removido da lista de tipos válidos do PostgreSQL */
- TipoPgSQL::removerTipoUsuario(objeto->getName(true), objeto);
+ PgSQLType::removeUserType(objeto->getName(true), objeto);
}
}
@@ -3495,7 +3495,7 @@ Function *ModeloBD::criarFuncao(void)
Function *funcao=NULL;
ObjectType tipo_obj;
BaseObject *objeto=NULL;
- TipoPgSQL tipo;
+ PgSQLType tipo;
Parameter param;
QString str_aux, elem;
@@ -3672,7 +3672,7 @@ Function *ModeloBD::criarFuncao(void)
Parameter ModeloBD::criarParametro(void)
{
- TipoPgSQL tipo;
+ PgSQLType tipo;
Parameter param;
map<QString, QString> atributos;
QString elem;
@@ -3728,7 +3728,7 @@ Parameter ModeloBD::criarParametro(void)
return(param);
}
-TipoPgSQL ModeloBD::criarTipoPgSQL(void)
+PgSQLType ModeloBD::criarTipoPgSQL(void)
{
map<QString, QString> atributos;
vector<void *> vet_ptipos;
@@ -3765,15 +3765,15 @@ TipoPgSQL ModeloBD::criarTipoPgSQL(void)
nome=atributos[ParsersAttributes::NAME];
- idx_tipo=TipoPgSQL::obterIndiceTipoBase(nome);
- if(idx_tipo!=TipoPgSQL::null)
+ idx_tipo=PgSQLType::getBaseTypeIndex(nome);
+ if(idx_tipo!=PgSQLType::null)
{
- return(TipoPgSQL(nome,comprimento,dimensao,precisao,com_timezone,tipo_interv, tipo_esp));
+ return(PgSQLType(nome,comprimento,dimensao,precisao,com_timezone,tipo_interv, tipo_esp));
}
else
{
//Obtém a lista de tipos definidios pelo usuario
- TipoPgSQL::obterTiposUsuario(vet_ptipos, this,
+ PgSQLType::getUserTypes(vet_ptipos, this,
UserTypeConfig::BASE_TYPE |
UserTypeConfig::DOMAIN_TYPE |
UserTypeConfig::TABLE_TYPE |
@@ -3800,8 +3800,8 @@ TipoPgSQL ModeloBD::criarTipoPgSQL(void)
if(!enc)
throw Exception(ERR_REF_INEXIST_USER_TYPE,__PRETTY_FUNCTION__,__FILE__,__LINE__);
- idx_tipo=TipoPgSQL::obterIndiceTipoUsuario(nome, ptipo);
- return(TipoPgSQL(idx_tipo,comprimento,dimensao,precisao,com_timezone,tipo_interv,tipo_esp));
+ idx_tipo=PgSQLType::getUserTypeIndex(nome, ptipo);
+ return(PgSQLType(idx_tipo,comprimento,dimensao,precisao,com_timezone,tipo_interv,tipo_esp));
}
}
@@ -3816,7 +3816,7 @@ Type *ModeloBD::criarTipo(void)
Parameter param;
BaseObject *funcao=NULL;
unsigned tipo_func=0;
- TipoPgSQL tipo_copia;
+ PgSQLType tipo_copia;
try
{
@@ -4067,7 +4067,7 @@ Cast *ModeloBD::criarConversaoTipo(void)
Cast *conv_tipo=NULL;
QString elem;
unsigned idx_tipo=0;
- TipoPgSQL tipo;
+ PgSQLType tipo;
BaseObject *funcao=NULL;
try
@@ -4238,7 +4238,7 @@ Operator *ModeloBD::criarOperador(void)
QString elem;
BaseObject *funcao=NULL,*oper_aux=NULL;
unsigned tipo_func, tipo_oper, tipo_arg;
- TipoPgSQL tipo;
+ PgSQLType tipo;
try
{
@@ -4370,7 +4370,7 @@ OperatorClass *ModeloBD::criarClasseOperadores(void)
map<QString, unsigned> tipos_elem;
BaseObject *objeto=NULL;
QString elem;
- TipoPgSQL tipo;
+ PgSQLType tipo;
OperatorClass *classe_op=NULL;
OperatorClassElement elem_classe;
bool rechecar;
@@ -4517,7 +4517,7 @@ Aggregate *ModeloBD::criarFuncaoAgregacao(void)
map<QString, QString> atributos;
BaseObject *funcao=NULL;
QString elem;
- TipoPgSQL tipo;
+ PgSQLType tipo;
Aggregate *func_agreg=NULL;
try
@@ -7914,9 +7914,9 @@ void ModeloBD::definirObjetosModificados(void)
}
}
-BaseObject *ModeloBD::obterObjetoTipoPgSQL(TipoPgSQL tipo)
+BaseObject *ModeloBD::obterObjetoTipoPgSQL(PgSQLType tipo)
{
- switch(tipo.obterConfTipoUsuario())
+ switch(tipo.getUserTypeConfig())
{
case UserTypeConfig::BASE_TYPE:
return(this->obterObjeto(*tipo, OBJ_TYPE));
View
4 libpgmodeler/src/modelobd.h
@@ -158,7 +158,7 @@ class ModeloBD: public QObject, public BaseObject {
/* Retorna o objeto do modelo o qual representa o tipo da dado PostgreSQL.
Basicamente esse método retorna uma tabela, sequencia, tipo ou domínio quando
o 'tipo' é um tipo de dado definido pelo usuário */
- BaseObject *obterObjetoTipoPgSQL(TipoPgSQL tipo);
+ BaseObject *obterObjetoTipoPgSQL(PgSQLType tipo);
public:
ModeloBD(void);
@@ -392,7 +392,7 @@ class ModeloBD: public QObject, public BaseObject {
//Métodos de criação de objetos a partir do documento XML
ObjectType getObjectType(const QString &str_tipo);
void definirAtributosBasicos(BaseObject *objeto);
- TipoPgSQL criarTipoPgSQL(void);
+ PgSQLType criarTipoPgSQL(void);
//Cria um objeto a partir do tipo passado
BaseObject *criarObjeto(ObjectType tipo_obj);
View
12 libpgmodeler/src/operator.cpp
@@ -13,8 +13,8 @@ Operator::Operator(void)
operators[i]=NULL;
hashes=merges=false;
- argument_types[LEFT_ARG]=TipoPgSQL("any");
- argument_types[RIGHT_ARG]=TipoPgSQL("any");
+ argument_types[LEFT_ARG]=PgSQLType("any");
+ argument_types[RIGHT_ARG]=PgSQLType("any");
attributes[ParsersAttributes::LEFT_TYPE]="";
attributes[ParsersAttributes::RIGHT_TYPE]="";
@@ -101,7 +101,7 @@ void Operator::setFunction(Function *func, unsigned func_type)
else
{
unsigned param_count=func->getParameterCount();
- TipoPgSQL param_type1=TipoPgSQL("any"), param_type2=TipoPgSQL("any");
+ PgSQLType param_type1=PgSQLType("any"), param_type2=PgSQLType("any");
//Get the function parameter to make validations
param_type1=func->getParameter(0).getType();
@@ -136,7 +136,7 @@ void Operator::setFunction(Function *func, unsigned func_type)
functions[func_type]=func;
}
-void Operator::setArgumentType(TipoPgSQL arg_type, unsigned arg_id)
+void Operator::setArgumentType(PgSQLType arg_type, unsigned arg_id)
{
//Raises an error if the argument id is invalid
if(arg_id > RIGHT_ARG)
@@ -203,7 +203,7 @@ Function *Operator::getFunction(unsigned func_type)
return(functions[func_type]);
}
-TipoPgSQL Operator::getArgumentType(unsigned arg_id)
+PgSQLType Operator::getArgumentType(unsigned arg_id)
{
//Raises an error if the argument id is invalid
if(arg_id > RIGHT_ARG)
@@ -278,7 +278,7 @@ QString Operator::getCodeDefinition(unsigned def_type, bool reduced_form)
else
{
attributes[atribs_tipos[i]]=argument_types[i].
- obterDefinicaoObjeto(SchemaParser::XML_DEFINITION,atribs_tipos[i]);
+ getObjectDefinition(SchemaParser::XML_DEFINITION,atribs_tipos[i]);
}
}
View
6 libpgmodeler/src/operator.h
@@ -32,7 +32,7 @@ class Operator: public BaseObject {
Function *functions[3];
//Stores the arguments types (left and right) used by the operator
- TipoPgSQL argument_types[2];
+ PgSQLType argument_types[2];
//Stores the auxiliary operators
Operator *operators[6];
@@ -64,7 +64,7 @@ class Operator: public BaseObject {
void setFunction(Function *func, unsigned func_type);
//Defines the argument data type for operator (constants ARG_[LEFT | RIGHT])
- void setArgumentType(TipoPgSQL arg_type, unsigned arg_id);
+ void setArgumentType(PgSQLType arg_type, unsigned arg_id);
//Defines the auxiliary operators (constants OPER_[COMMUTATOR | NEGATOR | SORT1 | SORT2 | LESS | GREATER])
void setOperator(Operator *oper, unsigned op_type);
@@ -79,7 +79,7 @@ class Operator: public BaseObject {
Function *getFunction(unsigned func_type);
//Returns the type of the passed argument id
- TipoPgSQL getArgumentType(unsigned arg_id);
+ PgSQLType getArgumentType(unsigned arg_id);
//Returns on of the auxiliary operators
Operator *getOperator(unsigned op_type);
View
8 libpgmodeler/src/operatorclass.cpp
@@ -17,10 +17,10 @@ OperatorClass::~OperatorClass(void)
elements.clear();
}
-void OperatorClass::setDataType(TipoPgSQL data_type)
+void OperatorClass::setDataType(PgSQLType data_type)
{
//A null datatype is not accepted by the operator class
- if(data_type==TipoPgSQL::null)
+ if(data_type==PgSQLType::null)
throw Exception(ERR_ASG_INV_TYPE_OBJECT,__PRETTY_FUNCTION__,__FILE__,__LINE__);
this->data_type=data_type;
@@ -117,7 +117,7 @@ unsigned OperatorClass::getElementCount(void)
return(elements.size());
}
-TipoPgSQL OperatorClass::getDataType(void)
+PgSQLType OperatorClass::getDataType(void)
{
return(data_type);
}
@@ -151,7 +151,7 @@ QString OperatorClass::getCodeDefinition(unsigned def_type, bool reduced_form)
if(def_type==SchemaParser::SQL_DEFINITION)
attributes[ParsersAttributes::TYPE]=(*data_type);
else
- attributes[ParsersAttributes::TYPE]=data_type.obterDefinicaoObjeto(def_type);
+ attributes[ParsersAttributes::TYPE]=data_type.getObjectDefinition(def_type);
if(family)
{
View
6 libpgmodeler/src/operatorclass.h
@@ -31,7 +31,7 @@
class OperatorClass: public BaseObject {
private:
//Data type witch the operator class acts on
- TipoPgSQL data_type;
+ PgSQLType data_type;
//Operator family that the operator class is part
OperatorFamily *family;
@@ -55,7 +55,7 @@ class OperatorClass: public BaseObject {
~OperatorClass(void);
//Sets the data type that the operator class works on
- void setDataType(TipoPgSQL data_type);
+ void setDataType(PgSQLType data_type);
//Sets the operator family that the operator class is part
void setFamily(OperatorFamily *family);
@@ -74,7 +74,7 @@ class OperatorClass: public BaseObject {
void removeElements(void);
//Methods used to obtain the class attributes
- TipoPgSQL getDataType(void);
+ PgSQLType getDataType(void);
OperatorFamily *getFamily(void);
IndexingType getIndexingType(void);
bool isDefault(void);
View
8 libpgmodeler/src/operatorclasselement.cpp
@@ -48,7 +48,7 @@ void OperatorClassElement::setOperator(Operator *oper, unsigned stg_number, bool
this->element_type=OPERATOR_ELEM;
}
-void OperatorClassElement::setStorage(TipoPgSQL storage)
+void OperatorClassElement::setStorage(PgSQLType storage)
{
//Clear the attributes not related to the STORAGE element type
this->function=NULL;
@@ -75,7 +75,7 @@ Operator *OperatorClassElement::getOperator(void)
return(_operator);
}
-TipoPgSQL OperatorClassElement::getStorage(void)
+PgSQLType OperatorClassElement::getStorage(void)
{
return(storage);
}
@@ -126,15 +126,15 @@ QString OperatorClassElement::getCodeDefinition(unsigned def_type)
else
attributes[ParsersAttributes::DEFINITION]=_operator->getCodeDefinition(def_type,true);
}
- else if(element_type==STORAGE_ELEM && storage!=TipoPgSQL::null)
+ else if(element_type==STORAGE_ELEM && storage!=PgSQLType::null)
{
//STORAGE storage_type
attributes[ParsersAttributes::STORAGE]="1";
if(def_type==SchemaParser::SQL_DEFINITION)
attributes[ParsersAttributes::TYPE]=(*storage);
else
- attributes[ParsersAttributes::DEFINITION]=storage.obterDefinicaoObjeto(def_type);
+ attributes[ParsersAttributes::DEFINITION]=storage.getObjectDefinition(def_type);
}
return(SchemaParser::getObjectDefinition(ParsersAttributes::ELEMENT,attributes, def_type));
View
6 libpgmodeler/src/operatorclasselement.h
@@ -44,7 +44,7 @@ class OperatorClassElement {
/* PostgreSQL type used in the indexing method of operator class.
(only for type STORAGE_ELEM) */
- TipoPgSQL storage;
+ PgSQLType storage;
//Inicates that the rechecking of retrieved lines is mandatory (only for OPERATOR_ELEM)
bool recheck;
@@ -68,7 +68,7 @@ class OperatorClassElement {
void setOperator(Operator *oper, unsigned stg_number, bool recheck);
//Defines the element as a storage clause
- void setStorage(TipoPgSQL storage);
+ void setStorage(PgSQLType storage);
//Returns the element type
unsigned getElementType(void);
@@ -82,7 +82,7 @@ class OperatorClassElement {
Operator *getOperator(void);
//Storage type of the element
- TipoPgSQL getStorage(void);
+ PgSQLType getStorage(void);
//Returns whether the elements is to be rechecked or not
bool isRecheck(void);
View
497 libpgmodeler/src/pgsqltypes.cpp
@@ -620,341 +620,339 @@ QString SpatialType::operator * (void)
* CLASSE: TipoPgSQL *
*********************/
//Inicializando a lista estática da classe
-vector<UserTypeConfig> TipoPgSQL::tipos_usr;
+vector<UserTypeConfig> PgSQLType::user_types;
-TipoPgSQL::TipoPgSQL(void)
+PgSQLType::PgSQLType(void)
{
type_idx=offset;
- comprimento=1;
- precisao=-1;
- dimensao=0;
- com_timezone=false;
+ length=1;
+ precision=-1;
+ dimension=0;
+ with_timezone=false;
}
-TipoPgSQL::TipoPgSQL(const QString &nome_tipo)
+PgSQLType::PgSQLType(const QString &type_name)
{
- (*this)=nome_tipo;
- comprimento=1;
- precisao=-1;
- dimensao=0;
- com_timezone=false;
+ (*this)=type_name;
+ length=1;
+ precision=-1;
+ dimension=0;
+ with_timezone=false;
}
-TipoPgSQL::TipoPgSQL(void *ptipo)
+PgSQLType::PgSQLType(void *ptype)
{
- (*this) << ptipo;
- comprimento=1;
- precisao=-1;
- dimensao=0;
- com_timezone=false;
+ (*this) << ptype;
+ length=1;
+ precision=-1;
+ dimension=0;
+ with_timezone=false;
}
-TipoPgSQL::TipoPgSQL(void *ptipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, IntervalType tipo_interv, SpatialType tipo_esp)
+PgSQLType::PgSQLType(void *ptype, unsigned length, unsigned dimension, int precision, bool with_timezone, IntervalType interv_type, SpatialType spatial_type)
{
- (*this) << ptipo;
- definirComprimento(comprimento);
- definirDimensao(dimensao);
- definirPrecisao(precisao);
- definirComTimezone(com_timezone);
- definirTipoIntervalo(tipo_interv);
- definirTipoEspacial(tipo_esp);
+ (*this) << ptype;
+ setLength(length);
+ setDimension(dimension);
+ setPrecision(precision);
+ setWithTimezone(with_timezone);
+ setIntervalType(interv_type);
+ setSpatialType(spatial_type);
}
-TipoPgSQL::TipoPgSQL(const QString &tipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, IntervalType tipo_interv, SpatialType tipo_esp)
+PgSQLType::PgSQLType(const QString &type_name, unsigned length, unsigned dimension, int precision, bool with_timezone, IntervalType interv_type, SpatialType spatial_type)
{
- (*this)=tipo;
- definirComprimento(comprimento);
- definirDimensao(dimensao);
- definirPrecisao(precisao);
- definirComTimezone(com_timezone);
- definirTipoIntervalo(tipo_interv);
- definirTipoEspacial(tipo_esp);
+ (*this)=type_name;
+ setLength(length);
+ setDimension(dimension);
+ setPrecision(precision);
+ setWithTimezone(with_timezone);
+ setIntervalType(interv_type);
+ setSpatialType(spatial_type);
}
-TipoPgSQL::TipoPgSQL(unsigned idx_tipo, unsigned comprimento, unsigned dimensao, int precisao, bool com_timezone, IntervalType tipo_interv, SpatialType tipo_esp)
+PgSQLType::PgSQLType(unsigned type_id, unsigned length, unsigned dimension, int precision, bool with_timezone, IntervalType interv_type, SpatialType spatial_type)
{
- (*this)=idx_tipo;
- definirComprimento(comprimento);
- definirDimensao(dimensao);
- definirPrecisao(precisao);
- definirComTimezone(com_timezone);
- definirTipoIntervalo(tipo_interv);
- definirTipoEspacial(tipo_esp);
+ (*this)=type_id;
+ setLength(length);
+ setDimension(dimension);
+ setPrecision(precision);
+ setWithTimezone(with_timezone);
+ setIntervalType(interv_type);
+ setSpatialType(spatial_type);
}
-void TipoPgSQL::getTypes(QStringList &tipos, bool tipo_oid, bool pseudos)
+void PgSQLType::getTypes(QStringList &type_list, bool oids, bool pseudos)
{
unsigned idx,total;
- tipos.clear(); //Limpa a lista de tipos
+ type_list.clear(); //Limpa a lista de tipos
total=offset+types_count; //Calcula a quantidade total de tipos a serem obtidos
for(idx=offset; idx<total; idx++)
{
//Insere na lista os tipos que vao do offset ao total de tipos
- if(idx<ini_oid ||
- (tipo_oid && idx>=ini_oid && idx<=fim_oid) ||
- (pseudos && idx>=ini_pseudo && idx<=fim_pseudo))
- tipos.push_back(BaseType::type_list[idx]);
+ if(idx<oid_start ||
+ (oids && idx>=oid_start && idx<=oid_end) ||
+ (pseudos && idx>=pseudo_start && idx<=pseudo_end))
+ type_list.push_back(BaseType::type_list[idx]);
}
}
-unsigned TipoPgSQL::operator = (unsigned tipo)
+unsigned PgSQLType::operator = (unsigned type_id)
{
- if(tipo>=offset)
- definirTipoUsuario(tipo);
- else if(tipo > 0)
- BaseType::setType(tipo,offset,types_count);
- else if(tipo==0)
+ if(type_id>=offset)
+ setUserType(type_id);
+ else if(type_id > 0)
+ BaseType::setType(type_id,offset,types_count);
+ else if(type_id==0)
throw Exception(ERR_ASG_INV_TYPE_OBJECT,__PRETTY_FUNCTION__,__FILE__,__LINE__);
return(type_idx);
}
-unsigned TipoPgSQL::operator = (const QString &nome_tipo)
+unsigned PgSQLType::operator = (const QString &type_name)
{
- unsigned idx_tipo, idx_tipo_usr;
+ unsigned type_idx, usr_type_idx;
- idx_tipo=BaseType::getType(nome_tipo, offset, types_count);
- idx_tipo_usr=obterIndiceTipoUsuario(nome_tipo, NULL);
+ type_idx=BaseType::getType(type_name, offset, types_count);
+ usr_type_idx=getUserTypeIndex(type_name, NULL);
- if(idx_tipo==0 && idx_tipo_usr==0)
+ if(type_idx==0 && usr_type_idx==0)
throw Exception(ERR_ASG_INV_TYPE_OBJECT,__PRETTY_FUNCTION__,__FILE__,__LINE__);
- else if(idx_tipo!=0)
+ else if(type_idx!=0)
{
- BaseType::setType(idx_tipo,offset,types_count);
- return(idx_tipo);
+ BaseType::setType(type_idx,offset,types_count);
+ return(type_idx);
}
else
{
- definirTipoUsuario(idx_tipo_usr);
- return(idx_tipo_usr);
+ setUserType(usr_type_idx);
+ return(usr_type_idx);
}
}
-void *TipoPgSQL::obterRefTipoUsuario(void)
+void *PgSQLType::getUserTypeReference(void)
{
- if(this->tipoUsuario())
- return(tipos_usr[this->type_idx - (fim_pseudo + 1)].ptype);
+ if(this->isUserType())
+ return(user_types[this->type_idx - (pseudo_end + 1)].ptype);
else
return(NULL);
}
-unsigned TipoPgSQL::obterConfTipoUsuario(void)
+unsigned PgSQLType::getUserTypeConfig(void)
{
- if(this->tipoUsuario())
- return(tipos_usr[this->type_idx - (fim_pseudo + 1)].type_conf);
+ if(this->isUserType())
+ return(user_types[this->type_idx - (pseudo_end + 1)].type_conf);
else
return(0);
}
-bool TipoPgSQL::operator == (unsigned idx_tipo)
+bool PgSQLType::operator == (unsigned type_id)
{
- return(this->type_idx==idx_tipo);
+ return(this->type_idx==type_id);
}
-bool TipoPgSQL::operator == (const QString &nome_tipo)
+bool PgSQLType::operator == (const QString &type_name)
{
unsigned idx,total;
- bool enc=false;
+ bool found=false;
total=offset + types_count; //Calculando o total de tipos da classe
/*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::type_list[idx]);
+ for(idx=offset; idx<total && !found; idx++)
+ found=(type_name==BaseType::type_list[idx]);
- if(enc) idx--;
+ if(found) idx--;
//Verifica se o código do tipo encontrado é igual ao codigo do tipo atual
return(type_idx==idx);
}
-bool TipoPgSQL::operator != (const QString &nome_tipo)
+bool PgSQLType::operator != (const QString &type_name)
{
- return(!((*this)==nome_tipo));
+ return(!((*this)==type_name));
}
-bool TipoPgSQL::operator != (TipoPgSQL tipo)
+bool PgSQLType::operator != (PgSQLType type)
{
- return(this->type_idx!=tipo.type_idx);
+ return(this->type_idx!=type.type_idx);
}
-bool TipoPgSQL::operator != (unsigned idx_tipo)
+bool PgSQLType::operator != (unsigned type_id)
{
- return(this->type_idx!=idx_tipo);
+ return(this->type_idx!=type_id);
}
-bool TipoPgSQL::operator == (TipoPgSQL tipo)
+bool PgSQLType::operator == (PgSQLType type)
{
- return(this->type_idx==tipo.type_idx);
+ return(this->type_idx==type.type_idx);
}
-bool TipoPgSQL::operator == (void *ptipo)
+bool PgSQLType::operator == (void *ptype)
{
int idx;
- idx=obterIndiceTipoUsuario("",ptipo);
+ idx=getUserTypeIndex("",ptype);
return(static_cast<int>(type_idx) == idx);
}
-IntervalType TipoPgSQL::obterTipoIntervalo(void)
+IntervalType PgSQLType::getIntervalType(void)
{
- return(tipo_intervalo);
+ return(interval_type);
}
-SpatialType TipoPgSQL::obterTipoEspacial(void)
+SpatialType PgSQLType::getSpatialType(void)
{
- return(tipo_espacial);
+ return(spatial_type);
}
-bool TipoPgSQL::comTimezone(void)
+bool PgSQLType::isWithTimezone(void)
{
- return(com_timezone);
+ return(with_timezone);
}
-bool TipoPgSQL::tipoOID(void)
+bool PgSQLType::isOIDType(void)
{
//Retorna se o tipo está no conjunto de tipos identificadores de objetos (oid)
- return(type_idx>=ini_oid && type_idx<=fim_oid);
+ return(type_idx>=oid_start && type_idx<=oid_end);
}
-bool TipoPgSQL::pseudoTipo(void)
+bool PgSQLType::isPseudoType(void)
{
//Retorna se o tipo está no conjunto de pseudotipos
- return(type_idx>=ini_pseudo && type_idx<=fim_pseudo);
+ return(type_idx>=pseudo_start && type_idx<=pseudo_end);
}
-unsigned TipoPgSQL::operator << (void *ptipo)
+unsigned PgSQLType::operator << (void *ptype)
{
- definirTipoUsuario(ptipo);
+ setUserType(ptype);
return(type_idx);
}
-void TipoPgSQL::definirTipoIntervalo(IntervalType tipo_interv)
+void PgSQLType::setIntervalType(IntervalType interv_type)
{
- tipo_intervalo=tipo_interv;
+ interval_type=interv_type;
}
-void TipoPgSQL::definirTipoEspacial(SpatialType tipo_esp)
+void PgSQLType::setSpatialType(SpatialType spat_type)
{
- tipo_espacial=tipo_esp;
+ spatial_type=spat_type;
}
-void TipoPgSQL::definirComTimezone(bool com_timezone)
+void PgSQLType::setWithTimezone(bool with_tz)
{
- this->com_timezone=com_timezone;
+ this->with_timezone=with_tz;
}
-void TipoPgSQL::definirTipoUsuario(unsigned idx)
+void PgSQLType::setUserType(unsigned type_id)
{
unsigned lim1, lim2;
- //lim1=offset + qtd_tipos +;
- //lim2=offset + qtd_tipos + TipoPgSQL::tipos_usr.size();
- lim1=fim_pseudo + 1;
- lim2=lim1 + TipoPgSQL::tipos_usr.size();
+ lim1=pseudo_end + 1;
+ lim2=lim1 + PgSQLType::user_types.size();
- if(TipoPgSQL::tipos_usr.size() > 0 &&
- (idx >= lim1 && idx < lim2))
- type_idx=idx;
+ if(PgSQLType::user_types.size() > 0 &&
+ (type_id >= lim1 && type_id < lim2))
+ type_idx=type_id;
else
throw Exception(ERR_ASG_INV_TYPE_OBJECT,__PRETTY_FUNCTION__,__FILE__,__LINE__);
}
-void TipoPgSQL::definirTipoUsuario(void *ptipo)
+void PgSQLType::setUserType(void *ptype)
{
int idx;
- idx=obterIndiceTipoUsuario("",ptipo);
+ idx=getUserTypeIndex("",ptype);
if(idx <= 0)
throw Exception(ERR_ASG_INV_TYPE_OBJECT,__PRETTY_FUNCTION__,__FILE__,__LINE__);
else
type_idx=idx;
}
-void TipoPgSQL::adicionarTipoUsuario(const QString &nome, void *ptipo, void *pmodelo, unsigned conf_tipo_usr)
+void PgSQLType::addUserType(const QString &type_name, void *ptype, void *pmodel, unsigned type_conf)
{
- if(nome!="" && ptipo && pmodelo &&
- (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)
+ if(type_name!="" && ptype && pmodel &&
+ (type_conf==UserTypeConfig::DOMAIN_TYPE ||
+ type_conf==UserTypeConfig::SEQUENCE_TYPE ||
+ type_conf==UserTypeConfig::TABLE_TYPE ||
+ type_conf==UserTypeConfig::BASE_TYPE) &&
+ getUserTypeIndex(type_name,ptype,pmodel)==0)
{
UserTypeConfig cfg;
- cfg.name=nome;
- cfg.ptype=ptipo;
- cfg.pmodel=pmodelo;
- cfg.type_conf=conf_tipo_usr;
- TipoPgSQL::tipos_usr.push_back(cfg);
+ cfg.name=type_name;
+ cfg.ptype=ptype;
+ cfg.pmodel=pmodel;
+ cfg.type_conf=type_conf;
+ PgSQLType::user_types.push_back(cfg);
}
}
-void TipoPgSQL::removerTipoUsuario(const QString &nome, void *ptipo)
+void PgSQLType::removeUserType(const QString &type_name, void *ptype)
{
- if(TipoPgSQL::tipos_usr.size() > 0 &&
- nome!="" && ptipo)
+ if(PgSQLType::user_types.size() > 0 &&
+ type_name!="" && ptype)
{
UserTypeConfig cfg;
vector<UserTypeConfig>::iterator itr, itr_end;
- itr=TipoPgSQL::tipos_usr.begin();
- itr_end=TipoPgSQL::tipos_usr.end();
+ itr=PgSQLType::user_types.begin();
+ itr_end=PgSQLType::user_types.end();
while(itr!=itr_end)
{
- if(itr->name==nome && itr->ptype==ptipo) break;
+ if(itr->name==type_name && itr->ptype==ptype) break;
else itr++;
}
if(itr!=itr_end)
- TipoPgSQL::tipos_usr.erase(itr);
+ PgSQLType::user_types.erase(itr);
}
}
-void TipoPgSQL::renomearTipoUsuario(const QString &nome, void *ptipo,const QString &novo_nome)
+void PgSQLType::renameUserType(const QString &type_name, void *ptype,const QString &new_name)
{
- if(TipoPgSQL::tipos_usr.size() > 0 &&
- nome!="" && ptipo && nome!=novo_nome)
+ if(PgSQLType::user_types.size() > 0 &&
+ type_name!="" && ptype && type_name!=new_name)
{
vector<UserTypeConfig>::iterator itr, itr_end;
- itr=TipoPgSQL::tipos_usr.begin();
- itr_end=TipoPgSQL::tipos_usr.end();
+ itr=PgSQLType::user_types.begin();
+ itr_end=PgSQLType::user_types.end();
while(itr!=itr_end)
{
- if(itr->name==nome && itr->ptype==ptipo)
+ if(itr->name==type_name && itr->ptype==ptype)
{
- itr->name=novo_nome;
+ itr->name=new_name;
break;
}
itr++;
}
}
}
-unsigned TipoPgSQL::obterIndiceTipoBase(const QString &nome)
+unsigned PgSQLType::getBaseTypeIndex(const QString &type_name)
{
- return(getType(nome,offset,types_count));
+ return(getType(type_name,offset,types_count));
}
-unsigned TipoPgSQL::obterIndiceTipoUsuario(const QString &nome, void *ptipo, void *pmodelo)
+unsigned PgSQLType::getUserTypeIndex(const QString &type_name, void *ptype, void *pmodel)
{
- if(TipoPgSQL::tipos_usr.size() > 0 && (nome!="" || ptipo))
+ if(PgSQLType::user_types.size() > 0 && (type_name!="" || ptype))
{
vector<UserTypeConfig>::iterator itr, itr_end;
int idx=0;
- itr=TipoPgSQL::tipos_usr.begin();
- itr_end=TipoPgSQL::tipos_usr.end();
+ itr=PgSQLType::user_types.begin();
+ itr_end=PgSQLType::user_types.end();
while(itr!=itr_end)
{
- if(((nome!="" && itr->name==nome) || (ptipo && itr->ptype==ptipo)) &&
- ((pmodelo && itr->pmodel==pmodelo) || !pmodelo))
+ if(((type_name!="" && itr->name==type_name) || (ptype && itr->ptype==ptype)) &&
+ ((pmodel && itr->pmodel==pmodel) || !pmodel))
break;
idx++;
@@ -963,82 +961,79 @@ unsigned TipoPgSQL::obterIndiceTipoUsuario(const QString &nome, void *ptipo, voi
if(itr!=itr_end)
//return(offset + qtd_tipos + idx);
- return(fim_pseudo + 1 + idx);
+ return(pseudo_end + 1 + idx);
else
return(BaseType::null);
}
else return(BaseType::null);
}
-QString TipoPgSQL::getNameTipoUsuario(unsigned idx)
+QString PgSQLType::getUserTypeName(unsigned type_id)
{
unsigned lim1, lim2;
- /*lim1=offset + qtd_tipos;
- lim2=offset + qtd_tipos + TipoPgSQL::tipos_usr.size();*/
-
- lim1=fim_pseudo + 1;
- lim2=lim1 + TipoPgSQL::tipos_usr.size();
+ lim1=pseudo_end + 1;
+ lim2=lim1 + PgSQLType::user_types.size();
- if(TipoPgSQL::tipos_usr.size() > 0 &&
- (idx >= lim1 && idx < lim2))
- return(TipoPgSQL::tipos_usr[idx - lim1].name);
+ if(PgSQLType::user_types.size() > 0 &&
+ (type_id >= lim1 && type_id < lim2))
+ return(PgSQLType::user_types[type_id - lim1].name);
else
return("");
}
-void TipoPgSQL::obterTiposUsuario(QStringList &tipos, void *pmodelo, unsigned inc_tipos_usr)
+void PgSQLType::getUserTypes(QStringList &type_list, void *pmodel, unsigned inc_usr_types)
{
unsigned idx,total;
- tipos.clear(); //Limpa a lista de tipos
- total=TipoPgSQL::tipos_usr.size();
+ type_list.clear(); //Limpa a lista de tipos
+ total=PgSQLType::user_types.size();
for(idx=0; idx < total; idx++)
{
//Só obtem os tipos definidos pelo usuário do modelo especificado
- 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);
+ if(user_types[idx].pmodel==pmodel &&
+ ((inc_usr_types & user_types[idx].type_conf) == user_types[idx].type_conf))
+ type_list.push_back(user_types[idx].name);
}
}
-void TipoPgSQL::obterTiposUsuario(vector<void *> &ptipos, void *pmodelo, unsigned inc_tipos_usr)
+void PgSQLType::getUserTypes(vector<void *> &ptypes, void *pmodel, unsigned inc_usr_types)
{
unsigned idx, total;
- ptipos.clear(); //Limpa a lista de tipos
- total=TipoPgSQL::tipos_usr.size();
+ ptypes.clear(); //Limpa a lista de tipos
+ total=PgSQLType::user_types.size();
for(idx=0; idx < total; idx++)
{
//Só obtem os tipos definidos pelo usuário do modelo especificado
- 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);
+ if(user_types[idx].pmodel==pmodel &&
+ ((inc_usr_types & user_types[idx].type_conf) == user_types[idx].type_conf))
+ ptypes.push_back(user_types[idx].ptype);
}
}
-QString TipoPgSQL::operator ~ (void)
+QString PgSQLType::operator ~ (void)
{
- if(type_idx >= fim_pseudo + 1)//offset + qtd_tipos)
- return(tipos_usr[type_idx - (fim_pseudo + 1)].name);
+ if(type_idx >= pseudo_end + 1)//offset + qtd_tipos)
+ return(user_types[type_idx - (pseudo_end + 1)].name);
else
return(BaseType::type_list[type_idx]);
}
-bool TipoPgSQL::tipoArray(void)
+bool PgSQLType::isArrayType(void)
{
- return(dimensao > 0);
+ return(dimension > 0);
}
-bool TipoPgSQL::tipoUsuario(void)
+bool PgSQLType::isUserType(void)
{
- return(type_idx > fim_pseudo);
+ return(type_idx > pseudo_end);
}
-bool TipoPgSQL::tipoCompVariavel(void )
+bool PgSQLType::hasVariableLength(void )
{
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" ||
@@ -1047,148 +1042,146 @@ return(type_list[this->type_idx]=="numeric" || type_list[this->type_idx]=="decim
type_list[this->type_idx]=="varbit");
}
-bool TipoPgSQL::tipoAceitaPrecisao(void )
+bool PgSQLType::acceptsPrecision(void )
{
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)
+void PgSQLType::setDimension(unsigned dim)
{
- if(dim > 0 && this->tipoUsuario())
+ if(dim > 0 && this->isUserType())
{
- int idx=obterIndiceTipoUsuario(~(*this), NULL);
- if(tipos_usr[idx].type_conf==UserTypeConfig::DOMAIN_TYPE ||
- tipos_usr[idx].type_conf==UserTypeConfig::SEQUENCE_TYPE)
+ int idx=getUserTypeIndex(~(*this), NULL);
+ if(user_types[idx].type_conf==UserTypeConfig::DOMAIN_TYPE ||
+ user_types[idx].type_conf==UserTypeConfig::SEQUENCE_TYPE)
throw Exception(ERR_ASG_INV_DOMAIN_ARRAY,__PRETTY_FUNCTION__,__FILE__,__LINE__);
}
- dimensao=dim;
+ dimension=dim;
}
-void TipoPgSQL::definirComprimento(unsigned comp)
+void PgSQLType::setLength(unsigned len)
{
//Caso o usuário tente criar um tipo de tamanho zero
- if(comp==0)
+ if(len==0)
//throw Excecao("Atribuição de comprimento igual a zero!");
throw Exception(ERR_ASG_ZERO_LENGTH,__PRETTY_FUNCTION__,__FILE__,__LINE__);
else
//Define o comprimento do tipo da coluna
- this->comprimento=comp;
+ this->length=len;
}
-void TipoPgSQL::definirPrecisao(int prec)
+void PgSQLType::setPrecision(int prec)
{
//Caso o usuário tente definir uma precisao maior que o comprimento do tipo
if(((BaseType::type_list[type_idx]=="numeric" ||
- BaseType::type_list[type_idx]=="decimal") && prec > static_cast<int>(comprimento)))
+ BaseType::type_list[type_idx]=="decimal") && prec > static_cast<int>(length)))
throw Exception(ERR_ASG_INV_PRECISION,__PRETTY_FUNCTION__,__FILE__,__LINE__);
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
- this->precisao=prec;
+ this->precision=prec;
}
-unsigned TipoPgSQL::obterDimensao(void)
+unsigned PgSQLType::getDimension(void)
{
- return(dimensao);
+ return(dimension);
}
-unsigned TipoPgSQL::obterComprimento(void)
+unsigned PgSQLType::getLength(void)
{
- return(comprimento);
+ return(length);
}
-int TipoPgSQL::obterPrecisao(void)
+int PgSQLType::getPrecision(void)
{
- return(precisao);
+ return(precision);
}
-QString TipoPgSQL::obterDefinicaoObjeto(unsigned tipo_def,QString tipo_ref)
+QString PgSQLType::getObjectDefinition(unsigned def_type,QString ref_type)
{
- if(tipo_def==SchemaParser::SQL_DEFINITION)
+ if(def_type==SchemaParser::SQL_DEFINITION)
return(*(*this));
else
{
- map<QString, QString> atributos;
+ map<QString, QString> attribs;
- atributos[ParsersAttributes::LENGTH]="";
- atributos[ParsersAttributes::DIMENSION]="";
- atributos[ParsersAttributes::PRECISION]="";
- atributos[ParsersAttributes::WITH_TIMEZONE]="";
- atributos[ParsersAttributes::INTERVAL_TYPE]="";
- atributos[ParsersAttributes::SPATIAL_TYPE]="";
- atributos[ParsersAttributes::VARIATION]="";
- atributos[ParsersAttributes::REF_TYPE]=tipo_ref;
+ attribs[ParsersAttributes::LENGTH]="";
+ attribs[ParsersAttributes::DIMENSION]="";
+ attribs[ParsersAttributes::PRECISION]="";
+ attribs[ParsersAttributes::WITH_TIMEZONE]="";
+ attribs[ParsersAttributes::INTERVAL_TYPE]="";
+ attribs[ParsersAttributes::SPATIAL_TYPE]="";
+ attribs[ParsersAttributes::VARIATION]="";
+ attribs[ParsersAttributes::REF_TYPE]=ref_type;
- atributos[ParsersAttributes::NAME]=(~(*this));
+ attribs[ParsersAttributes::NAME]=(~(*this));
- if(comprimento > 1)
- atributos[ParsersAttributes::LENGTH]=QString("%1").arg(this->comprimento);
+ if(length > 1)
+ attribs[ParsersAttributes::LENGTH]=QString("%1").arg(this->length);
- if(dimensao > 0)
- atributos[ParsersAttributes::DIMENSION]=QString("%1").arg(this->dimensao);
+ if(dimension > 0)
+ attribs[ParsersAttributes::DIMENSION]=QString("%1").arg(this->dimension);
- if(precisao >= 0)
- atributos[ParsersAttributes::PRECISION]=QString("%1").arg(this->precisao);
+ if(precision >= 0)
+ attribs[ParsersAttributes::PRECISION]=QString("%1").arg(this->precision);
- if(tipo_intervalo != BaseType::null)
- atributos[ParsersAttributes::INTERVAL_TYPE]=(~tipo_intervalo);
+ if(interval_type != BaseType::null)
+ attribs[ParsersAttributes::INTERVAL_TYPE]=(~interval_type);
- if(!tipoUsuario() && tipo_espacial != BaseType::null)
+ if(!isUserType() && spatial_type != BaseType::null)
{
- atributos[ParsersAttributes::SPATIAL_TYPE]=(~tipo_espacial);
- atributos[ParsersAttributes::VARIATION]=QString("%1").arg(tipo_espacial.getVariation());
+ attribs[ParsersAttributes::SPATIAL_TYPE]=(~spatial_type);
+ attribs[ParsersAttributes::VARIATION]=QString("%1").arg(spatial_type.getVariation());
}
- if(com_timezone)
- atributos[ParsersAttributes::WITH_TIMEZONE]="1";
+ if(with_timezone)
+ attribs[ParsersAttributes::WITH_TIMEZONE]="1";
- return(SchemaParser::getObjectDefinition("basetype",atributos, tipo_def));
+ return(SchemaParser::getObjectDefinition("basetype",attribs, def_type));
}
}
-QString TipoPgSQL::operator * (void)
+QString PgSQLType::operator * (void)
{
- QString tipo_fmt, tipo, aux;
+ QString fmt_type, type, aux;
unsigned idx;
- tipo=~(*this);
+ type=~(*this);
//Gerando definição de tipos espaciais (PostGiS)
- if(tipo=="geometry" || tipo=="geography")
- tipo_fmt=tipo + (*tipo_espacial);
- else if(comprimento > 1 && tipoCompVariavel())
+ if(type=="geometry" || type=="geography")
+ fmt_type=type + (*spatial_type);
+ else if(length > 1 && hasVariableLength())
{
/* Tratando o caso de tipos que necessitam de uma precisão.
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::type_list[type_idx]).arg(comprimento).arg(precisao);
+ if((type=="numeric" || type=="decimal") && precision>=0 &&
+ precision<=static_cast<int>(length))
+ aux=QString("%1(%2,%3)").arg(BaseType::type_list[type_idx]).arg(length).arg(precision);
/* Trantado o caso dos tipos que necessitam apenas do comprimento */
else
- aux=QString("%1(%2)").arg(BaseType::type_list[type_idx]).arg(comprimento);
+ aux=QString("%1(%2)").arg(BaseType::type_list[type_idx]).arg(length);
- tipo_fmt=aux;
+ fmt_type=aux;
}
- else if(tipo!="numeric" && tipo!="decimal" && tipoAceitaPrecisao())
+ else if(type!="numeric" && type!="decimal" && acceptsPrecision())
{
/* Tratando os tipos time e timestampe que possuem o formato:
[TIME|TIMESTAMP] (PRECISÃO) [WITH|WITHOUT] TIMEZONE */
- if(tipo!="interval")
+ if(type!="interval")
{
aux=BaseType::type_list[type_idx];
- if(precisao >= 0)
- aux+=QString("(%1)").arg(precisao);
+ if(precision >= 0)
+ aux+=QString("(%1)").arg(precision);
- //aux+=(com_timezone ? " with" : " without");
- //aux+=" time zone";
- if(com_timezone)
+ if(with_timezone)
aux+=" with time zone";
}
/* Tratando o tipo interval que possuem o formato:
@@ -1197,26 +1190,26 @@ QString TipoPgSQL::operator * (void)
{
aux=BaseType::type_list[type_idx];
- if(tipo_intervalo!=BaseType::null)
- aux+=QString("[%1]").arg(~tipo_intervalo);
+ if(interval_type!=BaseType::null)
+ aux+=QString("[%1]").arg(~interval_type);
- if(precisao >= 0)
- aux+=QString("(%1)").arg(precisao);
+ if(precision >= 0)
+ aux+=QString("(%1)").arg(precision);
}
- tipo_fmt=aux;
+ fmt_type=aux;
}
else
- tipo_fmt=tipo;
+ fmt_type=type;
- if(tipo!="void" && dimensao > 0)
+ if(type!="void" && dimension > 0)
{
- for(idx=0; idx < dimensao; idx++)
- tipo_fmt+="[]";
+ for(idx=0; idx < dimension; idx++)
+ fmt_type+="[]";
}
- return(tipo_fmt);
+ return(fmt_type);
}
/*************************
View
131 libpgmodeler/src/pgsqltypes.h
@@ -289,143 +289,144 @@ class UserTypeConfig {
UserTypeConfig(void)
{ name=""; ptype=NULL; pmodel=NULL; type_conf=BASE_TYPE; }
- friend class TipoPgSQL;
+ friend class PgSQLType;
};
-class TipoPgSQL: public BaseType{
+class PgSQLType: public BaseType{
private:
static const unsigned offset=25;
static const unsigned types_count=66;
//Offset dos tipos oid
- static const unsigned ini_oid=67;
- static const unsigned fim_oid=78;
+ static const unsigned oid_start=67;
+ static const unsigned oid_end=78;
//Offset dos pseudo-tipos
- static const unsigned ini_pseudo=79;
- static const unsigned fim_pseudo=90;
+ static const unsigned pseudo_start=79;
+ static const unsigned pseudo_end=90;
/* Apenas as classes Tipo (a qual criar SQL para tipos definidos pelo usuário)
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<UserTypeConfig> tipos_usr; //Lista de tipos de dados definidos pelo usuário
+ static vector<UserTypeConfig> user_types; //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,
+ unsigned dimension,
//Tamanho do tipo (exigido por tipos como varchar, date e bit)
- comprimento;
+ length;
//Precisão do valor do tipo (caso seja numeric/decimal)
- int precisao;
+ int precision;
/* Usado apenas para tipos time e timestamp e indica se o tempo
deve ser considerado com timezone (WITH/WITHOUT TIMEZONE) */
- bool com_timezone;
+ bool with_timezone;
//Tipo de intervalo de tempo usado pelo tipo de dado 'interval'
- IntervalType tipo_intervalo;
+ IntervalType interval_type;
//Tipo espacial usado na criação de tipos do PostGiS
- SpatialType tipo_espacial;
+ SpatialType spatial_type;
protected:
/* Adiciona uma nova referência ao tipo definido pelo usuário
(Esse método é chamando sempre que o tipo definido é criado) */
- static void adicionarTipoUsuario(const QString &nome, void *ptipo, void *pmodelo, unsigned conf_tipo);
+ static void addUserType(const QString &type_name, void *ptype, void *pmodel, unsigned type_conf);
/* Remove uma referência ao tipo definido pelo usuário
(Esse método é chamando sempre que o tipo definido é destruído) */
- static void removerTipoUsuario(const QString &nome, void *ptipo);
+ static void removeUserType(const QString &type_name, void *ptype);
/* Renomeia um tipo definido pelo usuário (Esse método é chamando sempre
que o tipo definido pelo usuário é renomeado) */
- static void renomearTipoUsuario(const QString &nome, void *ptipo, const QString &novo_nome);
+ static void renameUserType(const QString &type_name, void *ptype, const QString &new_name);
/* Obtém o nome do tipo definido pelo usuário através de seu índice.
Retorna vazio caso não índice seja inválido. */
- static QString getNameTipoUsuario(unsigned idx);
+ static QString getUserTypeName(unsigned type_id);
- void definirTipoUsuario(unsigned idx);
- void definirTipoUsuario(void *ptipo);
+ void setUserType(unsigned type_id);
+ void setUserType(void *ptype);
public:
- TipoPgSQL(void);
- TipoPgSQL(const QString &tipo);
- TipoPgSQL(void *ptipo);
- TipoPgSQL(const QString &tipo, unsigned comprimento,
- unsigned dimensao, int precisao,
- bool com_timezone, IntervalType tipo_interv,
- SpatialType tipo_esp);
- TipoPgSQL(void *ptipo, unsigned comprimento,
- unsigned dimensao, int precisao,
- bool com_timezone, IntervalType tipo_interv,
- SpatialType tipo_esp);
- TipoPgSQL(unsigned type_idx, unsigned comprimento,
- unsigned dimensao, int precisao,
- bool com_timezone, IntervalType tipo_interv,
- SpatialType tipo_esp);
+ PgSQLType(void);
+ PgSQLType(const QString &type_name);
+ PgSQLType(void *ptype);
+ PgSQLType(const QString &type_name, unsigned length,
+ unsigned dimension, int precision,
+ bool with_timezone, IntervalType interv_type,
+ SpatialType spatial_type);
+ PgSQLType(void *ptipo, unsigned length,
+ unsigned dimension, int precision,
+ bool with_timezone, IntervalType interv_type,
+ SpatialType spatial_type);
+ PgSQLType(unsigned type_id, unsigned length,
+ unsigned dimension, int precision,
+ bool with_timezone, IntervalType interv_type,
+ SpatialType spatial_type);
/* Obtém o índice referente a um tipo definido pelo usuário.
Retorna 0 caso o tipo não exista na lista. */
- static unsigned obterIndiceTipoUsuario(const QString &nome, void *ptipo, void *pmodelo=NULL);
- static unsigned obterIndiceTipoBase(const QString &nome);
+ static unsigned getUserTypeIndex(const QString &type_name, void *ptype, void *pmodel=NULL);
+ static unsigned getBaseTypeIndex(const QString &type_name);
//Obtém todos os tipos definidos pelo usuário
- 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 &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(IntervalType tipo_interv);
- void definirTipoEspacial(SpatialType tipo_espacial);
-
- unsigned obterDimensao(void);
- unsigned obterComprimento(void);
- int obterPrecisao(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
- bool tipoOID(void); //Retorna se o tipo é um identificador de tipo (OID)
- bool tipoUsuario(void); //Retorna se o tipo é um definido pelo usuário
- bool tipoArray(void); //Retorna se o tipo é usado como array
- bool tipoCompVariavel(void); //Retorna se o tipo aceita comprimento variável (varchar, varbit, char, etc)
- bool tipoAceitaPrecisao(void); //Retorna o tipo aceita precisão
+ static void getUserTypes(QStringList &type_list, void *pmodel, unsigned inc_usr_types);
+ static void getUserTypes(vector<void *> &ptypes, void *pmodel, unsigned inc_usr_types);
+ static void getTypes(QStringList &type_list, bool oids=true, bool pseudos=true);
+
+ void setDimension(unsigned dim);
+ void setLength(unsigned len);
+ void setPrecision(int prec);
+ void setWithTimezone(bool with_tz);
+ void setIntervalType(IntervalType interv_type);
+ void setSpatialType(SpatialType spat_type);
+
+ unsigned getDimension(void);
+ unsigned getLength(void);
+ int getPrecision(void);
+ IntervalType getIntervalType(void);
+ SpatialType getSpatialType(void);
+
+ bool isWithTimezone(void); //Retorna se o tipo considera timezone
+ bool isPseudoType(void); //Retorna se o tipo é um pseudo-tipo
+ bool isOIDType(void); //Retorna se o tipo é um identificador de tipo (OID)
+ bool isUserType(void); //Retorna se o tipo é um definido pelo usuário
+ bool isArrayType(void); //Retorna se o tipo é usado como array
+ bool hasVariableLength(void); //Retorna se o tipo aceita comprimento variável (varchar, varbit, char, etc)
+ bool acceptsPrecision(void); //Retorna o tipo aceita precisão
/* Como é necessário que o tipo base do PgSQL tenha uma definição XML
este método foi adicionad essa classe a qual configura um mapa
de atributos e passa ao parser de esquemas para que este retorne
a definição XML. Este método permite também se obter a definição
SQL do objeto, porém chamar este método para obtenção do SQL do tipo
é o mesmo que chamar o operador * do tipo. */
- QString obterDefinicaoObjeto(unsigned tipo_def,QString tipo_ref="");
+ QString getObjectDefinition(unsigned def_type, QString ref_type="");
QString operator ~ (void);
QString operator * (void); //Retorna a definiação SQL completa do tipo
unsigned operator << (void *ptipo);
unsigned operator = (unsigned tipo);
unsigned operator = (const QString &nome_tipo);
bool operator == (unsigned type_idx);
- bool operator == (TipoPgSQL tipo);
+ bool operator == (PgSQLType tipo);
bool operator == (const QString &nome_tipo);
bool operator == (void *ptipo);
bool operator != (const QString &nome_tipo);
- bool operator != (TipoPgSQL tipo);
+ bool operator != (PgSQLType tipo);
bool operator != (unsigned type_idx);
/* Retorna o ponteiro para o tipo definido pelo usuário que
denota o tipo pgsql em questão. Caso este operador seja usado
em um tipo que não é definido pelo usuário será retornado NULL */
- void *obterRefTipoUsuario(void);
+ void *getUserTypeReference(void);
+
//Retorna o tipo de configuração do tipo quando o mesmo é definido pelo usuário
- unsigned obterConfTipoUsuario(void);
+ unsigned getUserTypeConfig(void);
friend class Type;
friend class Domain;
View