src/sql/wsqlcolumn.cpp

Go to the documentation of this file.

/*
    WORM - a DAL/ORM code generation framework
    Copyright (C) 2011  Erik Winn <erikwinnmail@yahoo.com>

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// also, tests ..

#include "wsqlcolumn.h"

namespace WSql{

WSqlColumn::WSqlColumn()
{
    _columnName = std::string();
    _variableName = std::string();
    _isAutoIncremented = false;
    _isPrimaryKey = false;
    _isUnsigned = false;
    _canBeNull = true; //most dbms default .. 
    _precision = 2;
    _maxLength = -1;
    _type = WSqlDataType::NOTYPE;
}

WSqlColumn::WSqlColumn( const WSqlColumn& other )
{
    _columnName = other._columnName;
    _variableName = other._variableName;
    _isAutoIncremented = other._isAutoIncremented;
    _isPrimaryKey = other._isPrimaryKey;
    _isUnsigned = other._isUnsigned;
    _canBeNull = other._canBeNull;
    _precision = other._precision;
    _maxLength = other._maxLength;
    _type = other._type;
    _default = other._default;
}

WSqlColumn::~WSqlColumn()
{

}
WSqlColumn& WSqlColumn::operator=( const WSqlColumn & other )
{
    _columnName = other._columnName;
    _variableName = other._variableName;
    _isAutoIncremented = other._isAutoIncremented;
    _isPrimaryKey = other._isPrimaryKey;
    _isUnsigned = other._isUnsigned;
    _canBeNull = other._canBeNull;
    _precision = other._precision;
    _maxLength = other._maxLength;
    _type = other._type;
    _default = other._default;
    return *this;
}

bool WSqlColumn::operator==( const WSqlColumn& other ) const
{
    return ( _columnName == other._columnName
        && _variableName == other._variableName
        && _isAutoIncremented == other._isAutoIncremented
        && _isPrimaryKey == other._isPrimaryKey
        && _isUnsigned == other._isUnsigned
        && _canBeNull == other._canBeNull
        && _maxLength == other._maxLength
        && _precision == other._precision
        && _default == other._default
        && _type == other._type
    );
}

void WSqlColumn::setPrecision(int precision)
{
    _precision = precision;
}

void WSqlColumn::setDataType(WSqlDataType::Type type)
{
    _type = type;
}


void WSqlColumn::setColumnName(const std::string& name)
{
    _columnName = name;
    _variableName = WSqlDataType::columnNameToVariable(name);
}
void WSqlColumn::setVariableName(const std::string& name)
{
    _variableName = name;
}

const std::string& WSqlColumn::columnName() const
{
    return _columnName;
}
const std::string& WSqlColumn::variableName() const
{
    return _variableName;
}

const WSqlDataType::Type WSqlColumn::type() const
{
    return _type;
}

bool WSqlColumn::canBeNull() const
{
    return( _isAutoIncremented || _canBeNull);
}

const int WSqlColumn::maxLength() const
{
    return _maxLength;
}

const int WSqlColumn::precision() const
{
    return _precision;
}
std::string WSqlColumn::typeDeclaration() const
{
    std::string strToReturn;
    switch(_type){
        case WSqlDataType::NCHAR:
        case WSqlDataType::CHAR:
            strToReturn = "char";
            break;
        case WSqlDataType::TEXT:
        case WSqlDataType::TINYTEXT:
        case WSqlDataType::LONGTEXT:
        case WSqlDataType::MEDIUMTEXT:
        case WSqlDataType::VARCHAR:
        case WSqlDataType::NVARCHAR:
        case WSqlDataType::DATE:
        case WSqlDataType::DATETIME:
        case WSqlDataType::YEAR:
        case WSqlDataType::TIME:
        case WSqlDataType::TIMESTAMP:
        case WSqlDataType::TIMESTAMPTZ:
            strToReturn = "std::string";
            break;
        case WSqlDataType::TINYINT:
            strToReturn = "short";
            break;
        case WSqlDataType::SMALLINT:
        case WSqlDataType::MEDIUMINT:
        case WSqlDataType::INT:
            strToReturn = "int";
            break;
        case WSqlDataType::BIGINT:
            strToReturn = "long";
            break;
        case WSqlDataType::FLOAT:
            strToReturn = "float";
            break;
        case WSqlDataType::DECIMAL:
        case WSqlDataType::DOUBLE:
            strToReturn = "double";
            break;
        default:
            strToReturn = WSqlDataType::toString(_type);
    }
    return strToReturn;
}
bool WSqlColumn::typeIsSupported() const
{
    switch(_type){
        case WSqlDataType::NCHAR:
        case WSqlDataType::CHAR:
        case WSqlDataType::TEXT:
        case WSqlDataType::TINYTEXT:
        case WSqlDataType::LONGTEXT:
        case WSqlDataType::MEDIUMTEXT:
        case WSqlDataType::VARCHAR:
        case WSqlDataType::NVARCHAR:
        case WSqlDataType::DATE:
        case WSqlDataType::DATETIME:
        case WSqlDataType::YEAR:
        case WSqlDataType::TIME:
        case WSqlDataType::TIMESTAMP:
        case WSqlDataType::TIMESTAMPTZ:
        case WSqlDataType::TINYINT:
        case WSqlDataType::SMALLINT:
        case WSqlDataType::MEDIUMINT:
        case WSqlDataType::INT:
        case WSqlDataType::BIGINT:
        case WSqlDataType::FLOAT:
        case WSqlDataType::DECIMAL:
        case WSqlDataType::DOUBLE:
            return true;
        default:
            return false;
    }
}

// template<> std::string WSqlColumn::defaultValue<std::string>()
// {
//     return _default.data<std::string>();
// };

}//namespace WSql