numeric field phrase

src/dbgeography.cpp

@@ -2,7 +2,7 @@
 
 NUT_BEGIN_NAMESPACE
 
-DbGeography::DbGeography(QObject *parent) //: QObject(parent)
+DbGeography::DbGeography(QObject *parent)
 {
 
 }
@@ -29,7 +29,6 @@ void DbGeography::setLatitude(qreal latitude)
         return;
 
     m_latitude = latitude;
-//    emit latitudeChanged(latitude);
 }
 
 void DbGeography::setLongitude(qreal longitude)
@@ -38,7 +37,20 @@ void DbGeography::setLongitude(qreal longitude)
         return;
 
     m_longitude = longitude;
-//    emit longitudeChanged(longitude);
+}
+
+QString DbGeography::toString()
+{
+    return QString("%1,%2").arg(longitude()).arg(latitude());
+}
+
+void DbGeography::fromString(const QString &s)
+{
+    QStringList parts = s.split(',');
+    if (parts.count() == 2) {
+        setLongitude(parts[0].toDouble());
+        setLatitude(parts[1].toDouble());
+    }
 }
 
 NUT_END_NAMESPACE

src/dbgeography.h

@@ -9,10 +9,6 @@ NUT_BEGIN_NAMESPACE
 
 class NUT_EXPORT DbGeography //: public QObject
 {
-//    Q_PROPERTY(qreal latitude READ latitude WRITE setLatitude NOTIFY
-//                   latitudeChanged)
-//    Q_PROPERTY(qreal longitude READ longitude WRITE setLongitude NOTIFY
-//                   longitudeChanged)
     qreal m_latitude;
     qreal m_longitude;
 
@@ -23,13 +19,11 @@ public:
     qreal latitude() const;
     qreal longitude() const;
 
-//signals:
-//    void latitudeChanged(qreal latitude);
-//    void longitudeChanged(qreal longitude);
-
-//public slots:
     void setLatitude(qreal latitude);
     void setLongitude(qreal longitude);
+
+    QString toString();
+    void fromString(const QString &s);
 };
 
 NUT_END_NAMESPACE

src/mysqlgenerator.cpp

@@ -37,36 +37,36 @@ QString MySqlGenerator::fieldType(FieldModel *field)
 
     switch (field->type) {
     case QVariant::Bool:
-        dbType = "boolean";
+        dbType = "BOOLEAN";
         break;
     case QVariant::ByteArray:
-        dbType = "blob";
+        dbType = "BLOB";
         break;
     case QVariant::DateTime:
-        dbType = "datetime";
+        dbType = "DATETIME";
         break;
 
     case QVariant::Date:
-        dbType = "date";
+        dbType = "DATE";
         break;
 
     case QVariant::Time:
-        dbType = "time";
+        dbType = "TIME";
         break;
     case QVariant::Double:
-        dbType = "real";
+        dbType = "REAL";
         break;
     case QVariant::Int:
-        dbType = "int(4)";
+        dbType = "INT(4)";
         if(field->isAutoIncrement)
-            dbType += " auto_increment";
+            dbType += " AUTO_INCREMENT";
 
         break;
     case QVariant::String:
         if(field->length)
-            dbType = QString("varchar(%1)").arg(field->length);
+            dbType = QString("VARCHAR(%1)").arg(field->length);
         else
-            dbType = "text";
+            dbType = "TEXT";
         break;
 
     case QVariant::Point:
@@ -79,6 +79,10 @@ QString MySqlGenerator::fieldType(FieldModel *field)
         dbType = "POLYGON";
         break;
 
+    case QVariant::Uuid:
+        dbType = "VARCHAR(64)";
+        break;
+
     default:
         qWarning("Type %s::%s(%d) is not supported",
                  qPrintable(field->name),

src/postgresqlgenerator.cpp

@@ -35,39 +35,59 @@ QString PostgreSqlGenerator::fieldType(FieldModel *field)
 
     switch (field->type) {
     case QVariant::Bool:
-        dbType = "boolean";
+        dbType = "BOOLEAN";
         break;
     case QVariant::ByteArray:
-        dbType = "bytea";
+        dbType = "BYTEA";
         break;
     case QVariant::Date:
-        dbType = "date";
+        dbType = "DATE";
         break;
     case QVariant::DateTime:
-        dbType = "timestamp";
+        dbType = "TIMESTAMP";
         break;
     case QVariant::Time:
-        dbType = "time";
+        dbType = "TIME";
         break;
+
     case QVariant::Int:
+    case QVariant::UInt:
         if(field->isAutoIncrement)
-            dbType = "serial";
+            dbType = "SERIAL";
         else
-            dbType = "integer";
+            dbType = "INTEGER";
         break;
+
+    case QVariant::ULongLong:
+    case QVariant::LongLong:
+        if(field->isAutoIncrement)
+            dbType = "BIGSERIAL";
+        else
+            dbType = "BIGINTEGER";
+        break;
+
     case QVariant::Double:
-        dbType = "real";
+        dbType = "REAL";
         break;
     case QVariant::String:
         if(field->length)
-            dbType = QString("varchar(%1)").arg(field->length);
+            dbType = QString("VARCHAR(%1)").arg(field->length);
         else
-            dbType = "text";
+            dbType = "TEXT";
         break;
 
     case QVariant::Point:
     case QVariant::PointF:
-        dbType="point";
+        dbType="POINT";
+        break;
+
+    case QVariant::Uuid:
+        dbType = "UUID";
+        break;
+
+    case QVariant::Polygon:
+    case QVariant::PolygonF:
+        dbType = "POLYGON";
         break;
 
     default:

src/query.h

@@ -127,7 +127,7 @@ Q_OUTOFLINE_TEMPLATE QList<T *> Query<T>::toList(int count)
     QVariant lastPkValue = QVariant();
     int childTypeId = 0;
     T *lastRow = 0;
-    TableSetBase *childTableSet;
+    TableSetBase *childTableSet = Q_NULLPTR;
 
     //FIXME: getting table error
 //    QStringList masterFields = TableModel::findByName(d->tableName)->fieldsNames();
@@ -321,7 +321,7 @@ Q_OUTOFLINE_TEMPLATE int Query<T>::update(WherePhrase phrase)
                 d->wheres,
                 d->tableName);
     QSqlQuery q = d->database->exec(sql);
-
+qDebug()<<sql;
     if (m_autoDelete)
         deleteLater();
     return q.numRowsAffected();

src/sqlservergenerator.cpp

@@ -43,10 +43,10 @@ QString SqlServerGenerator::fieldType(FieldModel *field)
 
     switch (field->type) {
     case QVariant::Bool:
-        dbType = "bit";
+        dbType = "BIT";
         break;
     case QVariant::ByteArray:
-        dbType = "varbinary";
+        dbType = "VARBINARY";
 
         if(field->length)
             dbType.append(" (" + QString::number(field->length) + ")");
@@ -54,21 +54,21 @@ QString SqlServerGenerator::fieldType(FieldModel *field)
             dbType.append(" (MAX)");
         break;
     case QVariant::Date:
-        dbType = "date";
+        dbType = "DATE";
         break;
     case QVariant::DateTime:
-        dbType = "datetime";
+        dbType = "DATETIME";
         break;
     case QVariant::Time:
-        dbType = "time";
+        dbType = "TIME";
         break;
     case QVariant::Double:
-        dbType = "real";
+        dbType = "REAL";
         break;
     case QVariant::Int:
-        dbType = "int";
+        dbType = "INT";
         if(field->isAutoIncrement)
-            dbType += " identity(1,1)";
+            dbType += " IDENTITY(1,1)";
         break;
 
     case QVariant::Point:
@@ -78,10 +78,15 @@ QString SqlServerGenerator::fieldType(FieldModel *field)
 
     case QVariant::String:
         if(field->length)
-            dbType = QString("varchar(%1)").arg(field->length);
+            dbType = QString("NVARCHAR(%1)").arg(field->length);
         else
-            dbType = "varchar(max)";
+            dbType = "NVARCHAR(MAX)";
         break;
+
+    case QVariant::Uuid:
+        dbType = "UNIQUEIDENTIFIER";
+        break;
+
     default:
         dbType = "";
     }

src/wherephrase.cpp

@@ -200,34 +200,4 @@ WherePhrase WherePhrase::operator&(const WherePhrase &other)
     return WherePhrase(this, PhraseData::Append, (WherePhrase *)&other);
 }
 
-WherePhrase WherePhrase::operator==(const QVariant &other)
-{
-    return WherePhrase(this, PhraseData::Equal, other);
-}
-
-WherePhrase WherePhrase::operator!=(const QVariant &other)
-{
-    return WherePhrase(this, PhraseData::NotEqual, other);
-}
-
-WherePhrase WherePhrase::operator<(const QVariant &other)
-{
-    return WherePhrase(this, PhraseData::Less, other);
-}
-
-WherePhrase WherePhrase::operator>(const QVariant &other)
-{
-    return WherePhrase(this, PhraseData::Greater, other);
-}
-
-WherePhrase WherePhrase::operator<=(const QVariant &other)
-{
-    return WherePhrase(this, PhraseData::LessEqual, other);
-}
-
-WherePhrase WherePhrase::operator>=(const QVariant &other)
-{
-    return WherePhrase(this, PhraseData::GreaterEqual, other);
-}
-
 NUT_END_NAMESPACE

src/wherephrase.h

@@ -130,15 +130,6 @@ public:
 
     WherePhrase operator &(const WherePhrase &other);
 
-
-    WherePhrase operator ==(const QVariant &other);
-    WherePhrase operator !=(const QVariant &other);
-    WherePhrase operator <(const QVariant &other);
-    WherePhrase operator >(const QVariant &other);
-    WherePhrase operator <=(const QVariant &other);
-    WherePhrase operator >=(const QVariant &other);
-
-
     PhraseData *data() const;
 };
 
@@ -152,6 +143,13 @@ public:
     WherePhrase operator +(const QVariant &other);
     WherePhrase operator !();
 
+    WherePhrase operator ==(const QVariant &other);
+    WherePhrase operator !=(const QVariant &other);
+    WherePhrase operator <(const QVariant &other);
+    WherePhrase operator >(const QVariant &other);
+    WherePhrase operator <=(const QVariant &other);
+    WherePhrase operator >=(const QVariant &other);
+
     WherePhrase isNull();
     WherePhrase in(QList<T> list);
 //    WherePhrase in(QStringList list);
@@ -194,6 +192,42 @@ Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::operator !()
     return this;//WherePhrase(this, PhraseData::Not);
 }
 
+template<typename T>
+Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::operator==(const QVariant &other)
+{
+    return WherePhrase(this, PhraseData::Equal, other);
+}
+
+template<typename T>
+Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::operator!=(const QVariant &other)
+{
+    return WherePhrase(this, PhraseData::NotEqual, other);
+}
+
+template<typename T>
+Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::operator<(const QVariant &other)
+{
+    return WherePhrase(this, PhraseData::Less, other);
+}
+
+template<typename T>
+Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::operator>(const QVariant &other)
+{
+    return WherePhrase(this, PhraseData::Greater, other);
+}
+
+template<typename T>
+Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::operator<=(const QVariant &other)
+{
+    return WherePhrase(this, PhraseData::LessEqual, other);
+}
+
+template<typename T>
+Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::operator>=(const QVariant &other)
+{
+    return WherePhrase(this, PhraseData::GreaterEqual, other);
+}
+
 template<typename T>
 Q_OUTOFLINE_TEMPLATE WherePhrase FieldPhrase<T>::isNull(){
     return WherePhrase(this, PhraseData::Null);
@@ -267,6 +301,21 @@ public:
     }
 };
 
+
+//template<>
+//class FieldPhrase<QString>: public WherePhrase {
+//public:
+//    FieldPhrase(const char *className, const char* s) : WherePhrase(className, s){
+
+//    }
+
+//    WherePhrase like(QString pattern)
+//    {
+//        return WherePhrase(this, PhraseData::Like, pattern);
+//    }
+//};
+
+
 template<>
 class FieldPhrase<bool>: public WherePhrase{
 public:
@@ -287,6 +336,87 @@ public:
     }
 };
 
+class NumericFieldPhrase: public WherePhrase{
+public:
+    NumericFieldPhrase(const char *className, const char* s) : WherePhrase(className, s) { }
+
+    WherePhrase operator =(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::Set, other);
+    }
+
+    WherePhrase operator +(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::Add, other);
+    }
+
+    WherePhrase operator -(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::Minus, other);
+    }
+
+
+    WherePhrase operator ==(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::Equal, other);
+    }
+
+    WherePhrase operator !=(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::NotEqual, other);
+    }
+
+    WherePhrase operator <(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::Less, other);
+    }
+
+    WherePhrase operator >(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::Greater, other);
+    }
+
+    WherePhrase operator <=(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::LessEqual, other);
+    }
+
+    WherePhrase operator >=(const QVariant &other)
+    {
+        return WherePhrase(this, PhraseData::GreaterEqual, other);
+    }
+
+    WherePhrase isNull()
+    {
+        return WherePhrase(this, PhraseData::Null);
+    }
+};
+
+#define SPECIALIZATION_NUMERIC(type)                                                             \
+    template<>                                                                 \
+    class FieldPhrase<type>: public NumericFieldPhrase{                        \
+    public:                                                                    \
+        FieldPhrase(const char *className, const char* s)                      \
+            : NumericFieldPhrase(className, s) { }                             \
+        WherePhrase operator =(const WherePhrase &other)                       \
+        {                                                                      \
+            return WherePhrase(this, PhraseData::Set, (WherePhrase *)&other);  \
+        }                                                                      \
+        WherePhrase in(QList<type> list)                                      \
+        {                                                                      \
+            QVariantList vlist;                                                \
+            foreach (type t, list)                                                \
+                vlist.append(QVariant::fromValue(t));                          \
+            return WherePhrase(this, PhraseData::In, vlist);                   \
+        }                                                                      \
+    };
+
+SPECIALIZATION_NUMERIC(qint16)
+SPECIALIZATION_NUMERIC(qint32)
+SPECIALIZATION_NUMERIC(qint64)
+SPECIALIZATION_NUMERIC(qreal)
+
+
 NUT_END_NAMESPACE
 
 #endif // PHRASE_H