fieldtype.cc

有关MYSQL的开源码

#include "mysqlcppapi/fields/FieldType.h"
#include "mysqlcppapi/string_util.h"

namespace mysqlcppapi
{

FieldType::FieldType()
//FIELD_TYPE_NULL is an arbitrary default:
: m_field_type(FIELD_TYPE_NULL), m_bSigned(false), m_bCanBeNull(false),
  m_uiMaxLength(0), m_uiDecimalsCount(0), m_bNeedsQuotes(false)
{
  set_Type(m_field_type); //sets m_bNeedsQuotes.
}

FieldType::FieldType(enum_field_types fieldType, bool bSigned, bool bCanBeNull)
: m_field_type(fieldType), m_bSigned(bSigned), m_bCanBeNull(bCanBeNull),
  //Use set_* for these, or this constructor will have far too many arguments:
  m_uiMaxLength(0), m_uiDecimalsCount(0), m_bNeedsQuotes(false)
{
  set_Type(m_field_type); //sets m_bNeedsQuotes.
}  

FieldType::FieldType(const FieldType& other)
: m_field_type(other.m_field_type)
, m_bSigned(other.m_bSigned)
, m_bCanBeNull(other.m_bCanBeNull)
, m_uiMaxLength(other.m_uiMaxLength)
, m_uiDecimalsCount(other.m_uiDecimalsCount)
, m_bNeedsQuotes(other.m_bNeedsQuotes)
{
}

FieldType::~FieldType()
{
}

FieldType& FieldType::operator=(const FieldType& src)
{
  if (&src != this)
  {
    m_field_type = src.m_field_type;
    m_bSigned = src.m_bSigned;
    m_bCanBeNull = src.m_bCanBeNull;
    m_uiMaxLength = src.m_uiMaxLength;
    m_uiDecimalsCount = src.m_uiDecimalsCount;
    m_bNeedsQuotes = src.m_bNeedsQuotes;
  }
 
  return *this;
}

bool FieldType::operator==(const FieldType& src) const
{
  bool bEqual = ( m_field_type == src.m_field_type );
  bEqual = bEqual && ( m_bSigned == src.m_bSigned );
  bEqual = bEqual && ( m_bCanBeNull == src.m_bCanBeNull );
  bEqual = bEqual && ( m_uiMaxLength == src.m_uiMaxLength );
  bEqual = bEqual && ( m_uiDecimalsCount == src.m_uiDecimalsCount );
  bEqual = bEqual && ( m_bNeedsQuotes == src.m_bNeedsQuotes );

  return bEqual;
}

enum_field_types FieldType::get_Type() const
{
  return m_field_type;
}

bool FieldType::get_Signed() const
{
  return m_bSigned;
}

bool FieldType::get_CanBeNull() const
{
  return m_bCanBeNull;
}

void FieldType::set_Type(enum_field_types enumType)
{
  m_field_type = enumType;

  switch(m_field_type)
  {
    case(FIELD_TYPE_VAR_STRING):
    {
      m_bNeedsQuotes = true;

      //Some fields must have lengths, so set appropriate defaults:
      set_MaxLength(get_MaxLength()); //Overrides. Keep actual code in one place.
      break;
    }
    case(FIELD_TYPE_STRING):
    {
      m_bNeedsQuotes = true;
      break;
    }
    default:
    {
      m_bNeedsQuotes = false;
      break;
    }
  }
}

void FieldType::set_Signed(bool bVal)
{
  m_bSigned = bVal;
}

void FieldType::set_CanBeNull(bool bVal)
{
  m_bCanBeNull = bVal;
}

void FieldType::set_MaxLength(unsigned int uiVal)
{
  //0 means 'default', where a default is possible.
  m_uiMaxLength = uiVal;

  //Override value if it is invalid.
  //This method may also be called from set_Type().
  if( (m_field_type == FIELD_TYPE_VAR_STRING) && (m_uiMaxLength == 0) )
    m_uiMaxLength = 20; //Abritrary default.  
}

void FieldType::set_DecimalsCount(unsigned int uiVal)
{
  m_uiDecimalsCount = uiVal;
}

unsigned int FieldType::get_MaxLength() const
{
  return m_uiMaxLength;
}

unsigned int FieldType::get_DecimalsCount() const
{
  return m_uiDecimalsCount;
}

bool FieldType::get_NeedsQuotes() const
{
  return m_bNeedsQuotes;
}

bool FieldType::get_NeedsEscaping() const
{
  return get_NeedsQuotes();
}

FieldType::type_mapFieldTypes FieldType::get_mapFieldTypes()
{
  static type_mapFieldTypes mapFieldTypes;

  if (mapFieldTypes.empty())
  {
    mapFieldTypes[FIELD_TYPE_LONG] = "INTEGER";
    mapFieldTypes[FIELD_TYPE_FLOAT] = "FLOAT";
    mapFieldTypes[FIELD_TYPE_DOUBLE] = "DOUBLE";
    mapFieldTypes[FIELD_TYPE_DECIMAL] = "DECIMAL";
    mapFieldTypes[FIELD_TYPE_TINY] = "TINYINT";
    mapFieldTypes[FIELD_TYPE_SHORT] = "SMALLINT";
    mapFieldTypes[FIELD_TYPE_INT24] = "MEDIUMINT";
    mapFieldTypes[FIELD_TYPE_LONGLONG] = "BIGINT";
    
    mapFieldTypes[FIELD_TYPE_DATE] = "DATE";
    mapFieldTypes[FIELD_TYPE_TIME] = "TIME";
    mapFieldTypes[FIELD_TYPE_DATETIME] = "DATETIME";
    mapFieldTypes[FIELD_TYPE_YEAR] = "YEAR";
    mapFieldTypes[FIELD_TYPE_NEWDATE] = "NEWDATE";
    mapFieldTypes[FIELD_TYPE_TIMESTAMP] = "TIMESTAMP";
    
    mapFieldTypes[FIELD_TYPE_TINY_BLOB] = "TINYBLOB";
    mapFieldTypes[FIELD_TYPE_MEDIUM_BLOB] = "MEDIUMBLOB";
    mapFieldTypes[FIELD_TYPE_LONG_BLOB] = "LONGBLOB";
    mapFieldTypes[FIELD_TYPE_BLOB] = "BLOB";
    
    mapFieldTypes[FIELD_TYPE_VAR_STRING] = "VARCHAR";
    mapFieldTypes[FIELD_TYPE_STRING] = "CHAR";

    mapFieldTypes[FIELD_TYPE_ENUM] = "ENUM";
    mapFieldTypes[FIELD_TYPE_SET] = "SET";

    mapFieldTypes[FIELD_TYPE_NULL] = "NULL";
  }
  return mapFieldTypes;
}

std::string FieldType::sql(const std::string& strValue) const
{
  std::string strSQL = strValue;
  
  if(get_NeedsEscaping())
  {
    strSQL = escape(strValue);
  }

  if(get_NeedsQuotes())
  {
    strSQL.insert(strSQL.begin(), '"');
    strSQL.insert(strSQL.end(), '"');
  }
  else
  {
    //Non-string types should use NULL to mean no value. String types will have do this explicitly.
    if(strSQL.size() == 0)
      strSQL = "NULL";
  }

  return strSQL;
}

FieldType::enumTypeCategory FieldType::get_TypeCategory(enum_field_types fieldType)
{
  enumTypeCategory category = TYPE_CATEGORY_Unknown;

  switch(fieldType)
  {
    case(FIELD_TYPE_LONG):
    case(FIELD_TYPE_FLOAT):
    case(FIELD_TYPE_DOUBLE):
    case(FIELD_TYPE_DECIMAL):
    case(FIELD_TYPE_TINY):
    case(FIELD_TYPE_SHORT):
    case(FIELD_TYPE_INT24):
    case(FIELD_TYPE_LONGLONG):
    {
      category = TYPE_CATEGORY_Numeric;
      break;
    }
    
    case(FIELD_TYPE_DATE):
    case(FIELD_TYPE_TIME):
    case(FIELD_TYPE_DATETIME):
    case(FIELD_TYPE_YEAR):
    case(FIELD_TYPE_NEWDATE):
    case(FIELD_TYPE_TIMESTAMP):
    {
      category = TYPE_CATEGORY_DateAndTime;
      break;
    }
    
    case(FIELD_TYPE_TINY_BLOB):
    case(FIELD_TYPE_MEDIUM_BLOB):
    case(FIELD_TYPE_LONG_BLOB):
    case(FIELD_TYPE_BLOB):
    case(FIELD_TYPE_VAR_STRING):
    case(FIELD_TYPE_STRING):
    case(FIELD_TYPE_ENUM):
    case(FIELD_TYPE_SET):
    {
      category = TYPE_CATEGORY_String;
      break;
    }
    
    default:
    {
      category = TYPE_CATEGORY_Unknown;
      break;
    }
  }

  return category;
}

FieldType::enumTypeCategory FieldType::get_TypeCategory() const
{
  return get_TypeCategory(m_field_type);
}

FieldType::enumTypeOptionals FieldType::get_TypeOptionals(enum_field_types fieldType)
{
  enumTypeOptionals optionals = TYPE_OPTIONALS_None;

  switch(fieldType)
  {   
    case(FIELD_TYPE_TINY):
    case(FIELD_TYPE_SHORT):    
    case(FIELD_TYPE_INT24):
    case(FIELD_TYPE_LONG):
    case(FIELD_TYPE_LONGLONG):
    {
      optionals = TYPE_OPTIONALS_M_S;
      break;
    }
    
    case(FIELD_TYPE_FLOAT):
    case(FIELD_TYPE_DOUBLE):
    case(FIELD_TYPE_DECIMAL):
    {
      optionals = TYPE_OPTIONALS_M_D;
      break;
    }
    
    case(FIELD_TYPE_DATE):
    case(FIELD_TYPE_NEWDATE):  // ?
    case(FIELD_TYPE_TIME):
    case(FIELD_TYPE_DATETIME):
    case(FIELD_TYPE_YEAR):  //Can use (2|4) digits but I will not encourage use of non-default 2.
    case(FIELD_TYPE_TINY_BLOB):
    case(FIELD_TYPE_BLOB):
    case(FIELD_TYPE_MEDIUM_BLOB):
    case(FIELD_TYPE_LONG_BLOB):
    {
      optionals = TYPE_OPTIONALS_None;
    }
   
    case(FIELD_TYPE_TIMESTAMP):
    case(FIELD_TYPE_STRING): //CHAR
    case(FIELD_TYPE_VAR_STRING):  //VARCHAR
    {
      optionals = TYPE_OPTIONALS_M;
      break;
    }
  
    case(FIELD_TYPE_ENUM):
    case(FIELD_TYPE_SET):
    {
      optionals = TYPE_OPTIONALS_List;
      break;
    }
    
    default:
    {
      optionals = TYPE_OPTIONALS_None;
      break;
    }
  }

  return optionals;
}

FieldType::enumTypeOptionals FieldType::get_TypeOptionals() const
{
  return get_TypeOptionals(m_field_type);
}

} //namespace