fieldinfo.cc

有关MYSQL的开源码

#include "mysqlcppapi/fields/FieldInfo.h"
#include <cstdio>

namespace mysqlcppapi
{

FieldInfo::FieldInfo()
{
  m_bPrimaryKey = false;
  m_bUnique = false;
  m_bAutoIncrement = false;
}

FieldInfo::FieldInfo(const MYSQL_FIELD& mysqlField,  bool bFullFieldInfo /* = false */)
{
  //Field name:
  if(mysqlField.name)
    m_strName = mysqlField.name;

  //Field Type:
  bool bSigned = !(mysqlField.flags & UNSIGNED_FLAG);
  bool bCanBeNull = !(mysqlField.flags & NOT_NULL_FLAG);
  m_FieldType = FieldType(mysqlField.type, bSigned, bCanBeNull);

  //These values are only available when the MYSQL_RES result (that MYSQL_FIELD comes from) comes from mysql_list_fields().
  //Otherwise they may have uninitialized (random) values. This is annoying and stupid.
  {
	  unsigned int uiMaxLength = 0;
	  unsigned int uiDecimals = 0;
	  std::string strDefaultValue;
	  if(bFullFieldInfo)
	  {
	    uiMaxLength = mysqlField.max_length;
	    uiDecimals = mysqlField.decimals;

	    if(mysqlField.def)
	      strDefaultValue = mysqlField.def;
	  }
	   
	  m_FieldType.set_MaxLength(uiMaxLength);
	  m_FieldType.set_DecimalsCount(uiDecimals);
	  m_strDefaultValue = strDefaultValue;
  }

 //Is this a primary key?
 m_bPrimaryKey = (mysqlField.flags & PRI_KEY_FLAG);

 //Should the value be unique?
 m_bUnique = (mysqlField.flags & UNIQUE_KEY_FLAG);

 //Auto-Increment?
 m_bAutoIncrement = (mysqlField.flags & AUTO_INCREMENT_FLAG);

 if(mysqlField.table)
   m_strTableName = mysqlField.table;
  
}  

FieldInfo::FieldInfo(const FieldInfo& src)
{
  operator=(src);
}

FieldInfo::~FieldInfo()
{
}

FieldInfo& FieldInfo::operator=(const FieldInfo& src)
{
  m_strName = src.m_strName;
  m_FieldType = src.m_FieldType;
  m_strDefaultValue = src.m_strDefaultValue;
  m_bPrimaryKey = src.m_bPrimaryKey;
  m_bUnique = src.m_bUnique;
  m_bAutoIncrement = src.m_bAutoIncrement;
  
  return *this;
}

bool FieldInfo::operator==(const FieldInfo& src) const
{
  bool bEqual = ( m_strName == src.m_strName );
  bEqual = bEqual && ( m_FieldType == src.m_FieldType );
  bEqual = bEqual && ( m_strDefaultValue == src.m_strDefaultValue );
  bEqual = bEqual && ( m_bPrimaryKey == src.m_bPrimaryKey );
  bEqual = bEqual && ( m_bUnique == src.m_bUnique );
  bEqual = bEqual && ( m_bAutoIncrement == src.m_bAutoIncrement );
  
  return bEqual;
}

std::string FieldInfo::get_Name() const
{
  return m_strName;
}

std::string FieldInfo::get_DefaultValue() const
{
  return m_strDefaultValue;
}

bool FieldInfo::get_IsPrimaryKey() const
{
  return m_bPrimaryKey;
}

bool FieldInfo::get_IsUnique() const
{
  return m_bUnique;
}

bool FieldInfo::get_HasAutoIncrement() const
{
  return m_bAutoIncrement;
}
 
FieldType FieldInfo::get_FieldType() const
{
  return m_FieldType;
}

std::string FieldInfo::get_TableName() const
{
  return m_strTableName;
}

void FieldInfo::set_Name(const std::string& strVal)
{
  m_strName = strVal;
}

void FieldInfo::set_DefaultValue(const std::string& strVal)
{
  m_strDefaultValue = strVal;
}

void FieldInfo::set_IsPrimaryKey(bool bVal)
{
  m_bPrimaryKey = bVal;
}

void FieldInfo::set_IsUnique(bool bVal)
{
  m_bUnique = bVal;
}

void FieldInfo::set_HasAutoIncrement(bool bVal)
{
  m_bAutoIncrement = bVal;
}

void FieldInfo::set_FieldType(const FieldType& fieldType)
{
  m_FieldType = fieldType;
}

void FieldInfo::set_TableName(const std::string& strVal)
{
  m_strTableName = strVal;
}

std::string FieldInfo::get_field_definition() const
{
  std::string strResult;

  const FieldType fieldType = get_FieldType();
  
  //Type:
  FieldType::type_mapFieldTypes mapFieldTypes = FieldType::get_mapFieldTypes();
  
  std::string strType = "UnknownType";
  if(mapFieldTypes.find(fieldType.get_Type()) != mapFieldTypes.end())
    strType = mapFieldTypes[fieldType.get_Type()];
    strResult += strType;

  //Optinal type details: (M, D), UNSIGNED
  FieldType::enumTypeOptionals optionals = fieldType.get_TypeOptionals();
  if(optionals != FieldType::TYPE_OPTIONALS_None)
  {
	  std::string strOptionals;

	  char pchM[10] = {0};
	  sprintf(pchM, "%d", fieldType.get_MaxLength());
    std::string strM(pchM);	
	  
	  
	  if(optionals == FieldType::TYPE_OPTIONALS_M_D)
	  {
	    if( (fieldType.get_MaxLength() != 0) && ( fieldType.get_DecimalsCount() != 0) ) //0 here means use default, so don't specify.
	    { 
		    char pchD[10] = {0};
		    sprintf(pchD, "%d", fieldType.get_DecimalsCount());
	      std::string strD(pchD);	
	    
		    strOptionals = "(" + strM + "," + strD + ")";
	    }

	  }
	  else if(optionals == FieldType::TYPE_OPTIONALS_M_S)
	  {
	    if( fieldType.get_MaxLength() != 0 ) //0 here means use default, so don't specify.
	      strOptionals = "(" + strM + ")";

      if(!(fieldType.get_Signed()))
        strOptionals += " UNSIGNED";
	  }
	  else if(optionals == FieldType::TYPE_OPTIONALS_M)
	  {
      if( fieldType.get_MaxLength() != 0 ) //0 here means use default, so don't specify.
	      strOptionals = "(" + strM + ")";
	  }

    if(strOptionals.size())
      strResult += (" " + strOptionals);  
  }

  //Unique:
  if(get_IsUnique())
    strResult += " UNIQUE";

  //Not Null:
  if(!(fieldType.get_CanBeNull()))
    strResult += " NOT NULL";

  //Default:
  const std::string& strDefault =  get_DefaultValue();
  if(strDefault.size())
    strResult += " DEFAULT " + sql(strDefault); //Quote/Escape it if necessary.

  if(m_bAutoIncrement)
    strResult += " AUTO_INCREMENT ";

  //Primary Key:
  if(get_IsPrimaryKey())
    strResult += " PRIMARY KEY";
  
  return strResult;
}

std::string FieldInfo::sql(const std::string& strValue) const
{
  return m_FieldType.sql(strValue);
}

} //namespace