Stage 1 of incorporating database level precision policy.

Queries now ask the database object what precision they should be,
allows for setting precision policies on sql models, where previously
this was not available. Also fixes some failing precisionpolicy implementations,
as well as working around the fact qstring can't convert from "123.00" to
an int based type.

7 files changed, 109 insertions, 20 deletions

diff --git a/src/sql/kernel/qsqldatabase.cpp b/src/sql/kernel/qsqldatabase.cpp
index a270c0e..990ad9a 100644
--- a/src/sql/kernel/qsqldatabase.cpp
+++ b/src/sql/kernel/qsqldatabase.cpp
@@ -129,11 +129,16 @@ Q_GLOBAL_STATIC(QConnectionDict, dbDict)
 class QSqlDatabasePrivate
 {
 public:
-    QSqlDatabasePrivate(QSqlDriver *dr = 0):
+    QSqlDatabasePrivate(QSqlDatabase *d, QSqlDriver *dr = 0):
+        q(d),
         driver(dr),
         port(-1)
     {
         ref = 1;
+        if(driver)
+            precisionPolicy = driver->numericalPrecisionPolicy();
+        else
+            precisionPolicy= QSql::LowPrecisionDouble;
     }
     QSqlDatabasePrivate(const QSqlDatabasePrivate &other);
     ~QSqlDatabasePrivate();
@@ -142,6 +147,7 @@ public:
     void disable();
 
     QAtomicInt ref;
+    QSqlDatabase *q;
     QSqlDriver* driver;
     QString dbname;
     QString uname;
@@ -151,6 +157,7 @@ public:
     int port;
     QString connOptions;
     QString connName;
+    QSql::NumericalPrecisionPolicy precisionPolicy;
 
     static QSqlDatabasePrivate *shared_null();
     static QSqlDatabase database(const QString& name, bool open);
@@ -164,6 +171,7 @@ public:
 QSqlDatabasePrivate::QSqlDatabasePrivate(const QSqlDatabasePrivate &other)
 {
     ref = 1;
+    q = other.q;
     dbname = other.dbname;
     uname = other.uname;
     pword = other.pword;
@@ -172,6 +180,7 @@ QSqlDatabasePrivate::QSqlDatabasePrivate(const QSqlDatabasePrivate &other)
     port = other.port;
     connOptions = other.connOptions;
     driver = other.driver;
+    precisionPolicy = other.precisionPolicy;
 }
 
 QSqlDatabasePrivate::~QSqlDatabasePrivate()
@@ -216,7 +225,7 @@ DriverDict &QSqlDatabasePrivate::driverDict()
 QSqlDatabasePrivate *QSqlDatabasePrivate::shared_null()
 {
     static QSqlNullDriver dr;
-    static QSqlDatabasePrivate n(&dr);
+    static QSqlDatabasePrivate n(NULL, &dr);
     return &n;
 }
 
@@ -281,6 +290,7 @@ QSqlDatabase QSqlDatabasePrivate::database(const QString& name, bool open)
 */
 void QSqlDatabasePrivate::copy(const QSqlDatabasePrivate *other)
 {
+    q = other->q;
     dbname = other->dbname;
     uname = other->uname;
     pword = other->pword;
@@ -288,6 +298,7 @@ void QSqlDatabasePrivate::copy(const QSqlDatabasePrivate *other)
     drvName = other->drvName;
     port = other->port;
     connOptions = other->connOptions;
+    precisionPolicy = other->precisionPolicy;
 }
 
 void QSqlDatabasePrivate::disable()
@@ -658,7 +669,7 @@ QStringList QSqlDatabase::connectionNames()
 
 QSqlDatabase::QSqlDatabase(const QString &type)
 {
-    d = new QSqlDatabasePrivate();
+    d = new QSqlDatabasePrivate(this);
     d->init(type);
 }
 
@@ -670,7 +681,7 @@ QSqlDatabase::QSqlDatabase(const QString &type)
 
 QSqlDatabase::QSqlDatabase(QSqlDriver *driver)
 {
-    d = new QSqlDatabasePrivate(driver);
+    d = new QSqlDatabasePrivate(this, driver);
 }
 
 /*!
@@ -1469,6 +1480,42 @@ QString QSqlDatabase::connectionName() const
     return d->connName;
 }
 
+/*!
+
+  Sets the default numerical precision policy that queries use when created
+  on this database connection.
+
+  Note: Drivers that don't support fetching numerical values with low
+  precision will ignore the precision policy. You can use
+  QSqlDriver::hasFeature() to find out whether a driver supports this
+  feature.
+
+  Note: Setting the default precision policy doesn't affect any currently
+  active queries.
+
+  \sa QSql::NumericalPrecisionPolicy, numericalPrecisionPolicy(), QSqlQuery::setNumericalPrecisionPolicy(), QSqlQuery::numericalPrecisionPolicy()
+*/
+void QSqlDatabase::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy)
+{
+    if(driver())
+        driver()->setNumericalPrecisionPolicy(precisionPolicy);
+    d->precisionPolicy = precisionPolicy;
+}
+
+/*!
+  Returns the current default precision policy for the database connection.
+
+  \sa QSql::NumericalPrecisionPolicy, setNumericalPrecisionPolicy(), QSqlQuery::numericalPrecisionPolicy(), QSqlQuery::setNumericalPrecisionPolicy()
+*/
+QSql::NumericalPrecisionPolicy QSqlDatabase::numericalPrecisionPolicy() const
+{
+    if(driver())
+        return driver()->numericalPrecisionPolicy();
+    else
+        return d->precisionPolicy;
+}
+
+
 #ifndef QT_NO_DEBUG_STREAM
 QDebug operator<<(QDebug dbg, const QSqlDatabase &d)
 {
diff --git a/src/sql/kernel/qsqldatabase.h b/src/sql/kernel/qsqldatabase.h
index ca6f0b0..638a8a5 100644
--- a/src/sql/kernel/qsqldatabase.h
+++ b/src/sql/kernel/qsqldatabase.h
@@ -120,6 +120,8 @@ public:
     int port() const;
     QString connectOptions() const;
     QString connectionName() const;
+    void setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy);
+    QSql::NumericalPrecisionPolicy numericalPrecisionPolicy() const;
 
     QSqlDriver* driver() const;
 
diff --git a/src/sql/kernel/qsqldriver.cpp b/src/sql/kernel/qsqldriver.cpp
index 477d531..f7492c3 100644
--- a/src/sql/kernel/qsqldriver.cpp
+++ b/src/sql/kernel/qsqldriver.cpp
@@ -72,10 +72,11 @@ public:
     uint isOpen : 1;
     uint isOpenError : 1;
     QSqlError error;
+    QSql::NumericalPrecisionPolicy precisionPolicy;
 };
 
 inline QSqlDriverPrivate::QSqlDriverPrivate()
-    : QObjectPrivate(), isOpen(false), isOpenError(false)
+    : QObjectPrivate(), isOpen(false), isOpenError(false), precisionPolicy(QSql::LowPrecisionDouble)
 {
 }
 
@@ -912,4 +913,29 @@ QString QSqlDriver::stripDelimitersImplementation(const QString &identifier, Ide
     return ret;
 }
 
+/*!
+
+  Sets the default numerical precision policy that queries use when created
+  by this driver.
+
+  Note: Setting the default precision policy doesn't affect any currently
+  active queries.
+
+  \sa QSql::NumericalPrecisionPolicy, numericalPrecisionPolicy(), QSqlQuery::setNumericalPrecisionPolicy(), QSqlQuery::numericalPrecisionPolicy()
+*/
+void QSqlDriver::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy)
+{
+    d_func()->precisionPolicy = precisionPolicy;
+}
+
+/*!
+  Returns the current default precision policy for the database connection.
+
+  \sa QSql::NumericalPrecisionPolicy, setNumericalPrecisionPolicy(), QSqlQuery::numericalPrecisionPolicy(), QSqlQuery::setNumericalPrecisionPolicy()
+*/
+QSql::NumericalPrecisionPolicy QSqlDriver::numericalPrecisionPolicy() const
+{
+    return d_func()->precisionPolicy;
+}
+
 QT_END_NAMESPACE
diff --git a/src/sql/kernel/qsqldriver.h b/src/sql/kernel/qsqldriver.h
index 8ac1471..1b52437 100644
--- a/src/sql/kernel/qsqldriver.h
+++ b/src/sql/kernel/qsqldriver.h
@@ -130,6 +130,9 @@ public:
     bool isIdentifierEscaped(const QString &identifier, IdentifierType type) const; // ### Qt 5: make virtual
     QString stripDelimiters(const QString &identifier, IdentifierType type) const;  // ### Qt 5: make virtual
 
+    void setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy);
+    QSql::NumericalPrecisionPolicy numericalPrecisionPolicy() const;
+
 Q_SIGNALS:
     void notification(const QString &name);
 
diff --git a/src/sql/kernel/qsqlquery.cpp b/src/sql/kernel/qsqlquery.cpp
index 2a07e28..2e531b4 100644
--- a/src/sql/kernel/qsqlquery.cpp
+++ b/src/sql/kernel/qsqlquery.cpp
@@ -61,7 +61,6 @@ public:
     ~QSqlQueryPrivate();
     QAtomicInt ref;
     QSqlResult* sqlResult;
-    QSql::NumericalPrecisionPolicy precisionPolicy;
 
     static QSqlQueryPrivate* shared_null();
 };
@@ -81,7 +80,7 @@ QSqlQueryPrivate* QSqlQueryPrivate::shared_null()
 \internal
 */
 QSqlQueryPrivate::QSqlQueryPrivate(QSqlResult* result)
-    : ref(1), sqlResult(result), precisionPolicy(QSql::HighPrecision)
+    : ref(1), sqlResult(result)
 {
     if (!sqlResult)
         sqlResult = nullResult();
@@ -351,14 +350,14 @@ bool QSqlQuery::exec(const QString& query)
     if (d->ref != 1) {
         bool fo = isForwardOnly();
         *this = QSqlQuery(driver()->createResult());
-        d->sqlResult->setNumericalPrecisionPolicy(d->precisionPolicy);
+        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
         setForwardOnly(fo);
     } else {
         d->sqlResult->clear();
         d->sqlResult->setActive(false);
         d->sqlResult->setLastError(QSqlError());
         d->sqlResult->setAt(QSql::BeforeFirstRow);
-        d->sqlResult->setNumericalPrecisionPolicy(d->precisionPolicy);
+        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
     }
     d->sqlResult->setQuery(query.trimmed());
     if (!driver()->isOpen() || driver()->isOpenError()) {
@@ -891,12 +890,12 @@ bool QSqlQuery::prepare(const QString& query)
         bool fo = isForwardOnly();
         *this = QSqlQuery(driver()->createResult());
         setForwardOnly(fo);
-        d->sqlResult->setNumericalPrecisionPolicy(d->precisionPolicy);
+        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
     } else {
         d->sqlResult->setActive(false);
         d->sqlResult->setLastError(QSqlError());
         d->sqlResult->setAt(QSql::BeforeFirstRow);
-        d->sqlResult->setNumericalPrecisionPolicy(d->precisionPolicy);
+        d->sqlResult->setNumericalPrecisionPolicy(d->sqlResult->numericalPrecisionPolicy());
     }
     if (!driver()) {
         qWarning("QSqlQuery::prepare: no driver");
@@ -1126,10 +1125,10 @@ QVariant QSqlQuery::lastInsertId() const
   Instruct the database driver to return numerical values with a
   precision specified by \a precisionPolicy.
 
-  The Oracle driver, for example, retrieves numerical values as
-  strings by default to prevent the loss of precision. If the high
-  precision doesn't matter, use this method to increase execution
-  speed by bypassing string conversions.
+  The Oracle driver, for example, can retrieve numerical values as
+  strings to prevent the loss of precision. If high precision doesn't
+  matter, use this method to increase execution speed by bypassing
+  string conversions.
 
   Note: Drivers that don't support fetching numerical values with low
   precision will ignore the precision policy. You can use
@@ -1144,7 +1143,7 @@ QVariant QSqlQuery::lastInsertId() const
 */
 void QSqlQuery::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy precisionPolicy)
 {
-    d->precisionPolicy = precisionPolicy;
+    d->sqlResult->setNumericalPrecisionPolicy(precisionPolicy);
 }
 
 /*!
@@ -1154,7 +1153,7 @@ void QSqlQuery::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy preci
 */
 QSql::NumericalPrecisionPolicy QSqlQuery::numericalPrecisionPolicy() const
 {
-    return d->precisionPolicy;
+    return d->sqlResult->numericalPrecisionPolicy();
 }
 
 /*!
diff --git a/src/sql/kernel/qsqlresult.cpp b/src/sql/kernel/qsqlresult.cpp
index 180bfc7..a621b24 100644
--- a/src/sql/kernel/qsqlresult.cpp
+++ b/src/sql/kernel/qsqlresult.cpp
@@ -48,6 +48,7 @@
 #include "qsqlresult.h"
 #include "qvector.h"
 #include "qsqldriver.h"
+#include <QDebug>
 
 QT_BEGIN_NAMESPACE
 
@@ -64,7 +65,7 @@ class QSqlResultPrivate
 public:
     QSqlResultPrivate(QSqlResult* d)
     : q(d), sqldriver(0), idx(QSql::BeforeFirstRow), active(false),
-      isSel(false), forwardOnly(false), bindCount(0), binds(QSqlResult::PositionalBinding)
+      isSel(false), forwardOnly(false), precisionPolicy(QSql::LowPrecisionDouble), bindCount(0), binds(QSqlResult::PositionalBinding)
     {}
 
     void clearValues()
@@ -104,6 +105,7 @@ public:
     bool isSel;
     QSqlError error;
     bool forwardOnly;
+    QSql::NumericalPrecisionPolicy precisionPolicy;
 
     int bindCount;
     QSqlResult::BindingSyntax binds;
@@ -249,6 +251,9 @@ QSqlResult::QSqlResult(const QSqlDriver *db)
 {
     d = new QSqlResultPrivate(this);
     d->sqldriver = db;
+    if(db) {
+        setNumericalPrecisionPolicy(db->numericalPrecisionPolicy());
+    }
 }
 
 /*!
@@ -965,8 +970,14 @@ void QSqlResult::detachFromResultSet()
  */
 void QSqlResult::setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy)
 {
-    if (driver()->hasFeature(QSqlDriver::LowPrecisionNumbers))
-        virtual_hook(SetNumericalPrecision, &policy);
+    d->precisionPolicy = policy;
+}
+
+/*! \internal
+ */
+QSql::NumericalPrecisionPolicy QSqlResult::numericalPrecisionPolicy() const
+{
+    return d->precisionPolicy;
 }
 
 /*! \internal
diff --git a/src/sql/kernel/qsqlresult.h b/src/sql/kernel/qsqlresult.h
index 0a3d8b9..30c933b 100644
--- a/src/sql/kernel/qsqlresult.h
+++ b/src/sql/kernel/qsqlresult.h
@@ -135,6 +135,7 @@ protected:
     bool execBatch(bool arrayBind = false);
     void detachFromResultSet();
     void setNumericalPrecisionPolicy(QSql::NumericalPrecisionPolicy policy);
+    QSql::NumericalPrecisionPolicy numericalPrecisionPolicy() const;
     bool nextResult();
 
 private: