diff --git a/src/KDbConnection.h b/src/KDbConnection.h
--- a/src/KDbConnection.h
+++ b/src/KDbConnection.h
@@ -20,6 +20,7 @@
 #ifndef KDB_CONNECTION_H
 #define KDB_CONNECTION_H
 
+#include "KDbCursor.h"
 #include "KDbDriver.h"
 #include "KDbPreparedStatement.h"
 #include "KDbTableSchema.h"
@@ -30,7 +31,6 @@
 class KDbConnectionData;
 class KDbConnectionOptions;
 class KDbConnectionProxy;
-class KDbCursor;
 class KDbDriver;
 class KDbProperties;
 class KDbRecordData;
@@ -363,68 +363,70 @@
      @return opened cursor created for results of this query
      or @c nullptr if there was any error. Ownership of the returned object is passed
      to the caller.
-     KDbCursor can have optionally applied @a cursor_options (one of more selected from KDbCursor::Options).
+     KDbCursor can have optionally applied @a options (one of more selected from KDbCursor::Options).
      Preparation means that returned cursor is created but not opened.
      Open this when you would like to do it with KDbCursor::open().
 
      Note for driver developers: you should initialize cursor engine-specific
      resources and return KDbCursor subclass' object
-     (passing @a sql and @a cursor_options to its constructor).
+     (passing @a sql and @a options to its constructor).
     */
-    virtual KDbCursor* prepareQuery(const KDbEscapedString& sql, int cursor_options = 0) Q_REQUIRED_RESULT = 0;
+    virtual KDbCursor* prepareQuery(const KDbEscapedString& sql,
+                                    KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT = 0;
 
-    /*! @overload prepareQuery(const KDbEscapedString&, int)
+    /*! @overload
      Prepares query described by @a query schema. @a params are values of parameters that
      will be inserted into places marked with [] before execution of the query.
 
      Note for driver developers: you should initialize cursor engine-specific
      resources and return KDbCursor subclass' object
-     (passing @a query and @a cursor_options to it's constructor).
+     (passing @a query and @a options to it's constructor).
      Kexi SQL and driver-specific escaping is performed on table names.
     */
     KDbCursor* prepareQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-                            int cursor_options = 0) Q_REQUIRED_RESULT;
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT;
 
-    /*! @overload prepareQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-      int cursor_options = 0 )
+    /*! @overload
      Prepares query described by @a query schema without parameters.
     */
-    virtual KDbCursor* prepareQuery(KDbQuerySchema* query, int cursor_options = 0) Q_REQUIRED_RESULT = 0;
+    virtual KDbCursor* prepareQuery(KDbQuerySchema* query,
+                                    KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT = 0;
 
-    /*! @overload prepareQuery(const KDbEscapedString&, int)
-     Statement is build from data provided by @a table schema,
-     it is like "select * from table_name".*/
-    KDbCursor* prepareQuery(KDbTableSchema* table, int cursor_options = 0) Q_REQUIRED_RESULT;
+    /*! @overload
+     Statement is build from data provided by @a table schema, it is like "select * from table_name".*/
+    KDbCursor* prepareQuery(KDbTableSchema* table,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT;
 
     /*! Executes SELECT query described by a raw SQL statement @a sql.
      @return opened cursor created for results of this query
      or 0 if there was any error on the cursor creation or opening.
      Ownership of the returned object is passed to the caller.
-     KDbCursor can have optionally applied @a cursor_options
-     (one of more selected from KDbCursor::Options).
+     KDbCursor can have optionally applied @a options.
      Identifiers in @a sql that are the same as keywords
      in KDbSQL dialect or the backend's SQL have to be escaped.
      */
-    KDbCursor* executeQuery(const KDbEscapedString& sql, int cursor_options = 0) Q_REQUIRED_RESULT;
+    KDbCursor* executeQuery(const KDbEscapedString& sql,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT;
 
     /*! @overload executeQuery(const KDbEscapedString&, int)
      @a params are values of parameters that
      will be inserted into places marked with [] before execution of the query.
 
      Statement is build from data provided by @a query schema.
      Kexi SQL and driver-specific escaping is performed on table names. */
     KDbCursor* executeQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-                            int cursor_options = 0) Q_REQUIRED_RESULT;
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT;
 
-    /*! @overload executeQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-      int cursor_options = 0 ) */
-    KDbCursor* executeQuery(KDbQuerySchema* query, int cursor_options = 0) Q_REQUIRED_RESULT;
+    /*! @overload */
+    KDbCursor* executeQuery(KDbQuerySchema* query,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT;
 
-    /*! @overload executeQuery(const KDbEscapedString&, int)
+    /*! @overload
      Executes query described by @a query schema without parameters.
      Statement is build from data provided by @a table schema,
      it is like "select * from table_name".*/
-    KDbCursor* executeQuery(KDbTableSchema* table, int cursor_options = 0) Q_REQUIRED_RESULT;
+    KDbCursor* executeQuery(KDbTableSchema* table,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_REQUIRED_RESULT;
 
     /*! Deletes cursor @a cursor previously created by functions like executeQuery()
      for this connection.
diff --git a/src/KDbConnection.cpp b/src/KDbConnection.cpp
--- a/src/KDbConnection.cpp
+++ b/src/KDbConnection.cpp
@@ -1964,11 +1964,11 @@
     return true;
 }
 
-KDbCursor* KDbConnection::executeQuery(const KDbEscapedString& sql, int cursor_options)
+KDbCursor* KDbConnection::executeQuery(const KDbEscapedString& sql, KDbCursor::Options options)
 {
     if (sql.isEmpty())
         return 0;
-    KDbCursor *c = prepareQuery(sql, cursor_options);
+    KDbCursor *c = prepareQuery(sql, options);
     if (!c)
         return 0;
     if (!c->open()) {//err - kill that
@@ -1980,9 +1980,9 @@
 }
 
 KDbCursor* KDbConnection::executeQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-                                       int cursor_options)
+                                       KDbCursor::Options options)
 {
-    KDbCursor *c = prepareQuery(query, params, cursor_options);
+    KDbCursor *c = prepareQuery(query, params, options);
     if (!c)
         return 0;
     if (!c->open()) {//err - kill that
@@ -1993,25 +1993,25 @@
     return c;
 }
 
-KDbCursor* KDbConnection::executeQuery(KDbQuerySchema* query, int cursor_options)
+KDbCursor* KDbConnection::executeQuery(KDbQuerySchema* query, KDbCursor::Options options)
 {
-    return executeQuery(query, QList<QVariant>(), cursor_options);
+    return executeQuery(query, QList<QVariant>(), options);
 }
 
-KDbCursor* KDbConnection::executeQuery(KDbTableSchema* table, int cursor_options)
+KDbCursor* KDbConnection::executeQuery(KDbTableSchema* table, KDbCursor::Options options)
 {
-    return executeQuery(table->query(), cursor_options);
+    return executeQuery(table->query(), options);
 }
 
-KDbCursor* KDbConnection::prepareQuery(KDbTableSchema* table, int cursor_options)
+KDbCursor* KDbConnection::prepareQuery(KDbTableSchema* table, KDbCursor::Options options)
 {
-    return prepareQuery(table->query(), cursor_options);
+    return prepareQuery(table->query(), options);
 }
 
 KDbCursor* KDbConnection::prepareQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-                                       int cursor_options)
+                                       KDbCursor::Options options)
 {
-    KDbCursor* cursor = prepareQuery(query, cursor_options);
+    KDbCursor* cursor = prepareQuery(query, options);
     if (cursor)
         cursor->setQueryParameters(params);
     return cursor;
diff --git a/src/KDbConnectionProxy.h b/src/KDbConnectionProxy.h
--- a/src/KDbConnectionProxy.h
+++ b/src/KDbConnectionProxy.h
@@ -128,20 +128,20 @@
 
     KDbEscapedString escapeString(const QString& str) const Q_DECL_OVERRIDE;
 
-    KDbCursor* prepareQuery(const KDbEscapedString& sql, int cursor_options = 0) Q_DECL_OVERRIDE;
+    KDbCursor* prepareQuery(const KDbEscapedString& sql, KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE;
 
-    KDbCursor* prepareQuery(KDbQuerySchema* query, int cursor_options = 0) Q_DECL_OVERRIDE;
+    KDbCursor* prepareQuery(KDbQuerySchema* query, KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE;
 
-    KDbCursor* prepareQuery(KDbTableSchema* table, int cursor_options = 0);
+    KDbCursor* prepareQuery(KDbTableSchema* table, KDbCursor::Options options = KDbCursor::Option::None);
 
-    KDbCursor* executeQuery(const KDbEscapedString& sql, int cursor_options = 0);
+    KDbCursor* executeQuery(const KDbEscapedString& sql, KDbCursor::Options options = KDbCursor::Option::None);
 
     KDbCursor* executeQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-                            int cursor_options = 0);
+                            KDbCursor::Options options = KDbCursor::Option::None);
 
-    KDbCursor* executeQuery(KDbQuerySchema* query, int cursor_options = 0);
+    KDbCursor* executeQuery(KDbQuerySchema* query, KDbCursor::Options options = KDbCursor::Option::None);
 
-    KDbCursor* executeQuery(KDbTableSchema* table, int cursor_options = 0);
+    KDbCursor* executeQuery(KDbTableSchema* table, KDbCursor::Options options = KDbCursor::Option::None);
 
     bool deleteCursor(KDbCursor *cursor);
 
diff --git a/src/KDbConnectionProxy.cpp b/src/KDbConnectionProxy.cpp
--- a/src/KDbConnectionProxy.cpp
+++ b/src/KDbConnectionProxy.cpp
@@ -245,40 +245,40 @@
     return d->connection->escapeString(str);
 }
 
-KDbCursor* KDbConnectionProxy::prepareQuery(const KDbEscapedString& sql, int cursor_options)
+KDbCursor* KDbConnectionProxy::prepareQuery(const KDbEscapedString& sql, KDbCursor::Options options)
 {
-    return d->connection->prepareQuery(sql, cursor_options);
+    return d->connection->prepareQuery(sql, options);
 }
 
-KDbCursor* KDbConnectionProxy::prepareQuery(KDbQuerySchema* query, int cursor_options)
+KDbCursor* KDbConnectionProxy::prepareQuery(KDbQuerySchema* query, KDbCursor::Options options)
 {
-    return d->connection->prepareQuery(query, cursor_options);
+    return d->connection->prepareQuery(query, options);
 }
 
-KDbCursor* KDbConnectionProxy::prepareQuery(KDbTableSchema* table, int cursor_options)
+KDbCursor* KDbConnectionProxy::prepareQuery(KDbTableSchema* table, KDbCursor::Options options)
 {
-    return d->connection->prepareQuery(table, cursor_options);
+    return d->connection->prepareQuery(table, options);
 }
 
-KDbCursor* KDbConnectionProxy::executeQuery(const KDbEscapedString& sql, int cursor_options)
+KDbCursor* KDbConnectionProxy::executeQuery(const KDbEscapedString& sql, KDbCursor::Options options)
 {
-    return d->connection->executeQuery(sql, cursor_options);
+    return d->connection->executeQuery(sql, options);
 }
 
 KDbCursor* KDbConnectionProxy::executeQuery(KDbQuerySchema* query, const QList<QVariant>& params,
-                        int cursor_options)
+                        KDbCursor::Options options)
 {
-    return d->connection->executeQuery(query, params, cursor_options);
+    return d->connection->executeQuery(query, params, options);
 }
 
-KDbCursor* KDbConnectionProxy::executeQuery(KDbQuerySchema* query, int cursor_options)
+KDbCursor* KDbConnectionProxy::executeQuery(KDbQuerySchema* query, KDbCursor::Options options)
 {
-    return d->connection->executeQuery(query, cursor_options);
+    return d->connection->executeQuery(query, options);
 }
 
-KDbCursor* KDbConnectionProxy::executeQuery(KDbTableSchema* table, int cursor_options)
+KDbCursor* KDbConnectionProxy::executeQuery(KDbTableSchema* table, KDbCursor::Options options)
 {
-    return d->connection->executeQuery(table, cursor_options);
+    return d->connection->executeQuery(table, options);
 }
 
 bool KDbConnectionProxy::deleteCursor(KDbCursor *cursor)
diff --git a/src/KDbCursor.h b/src/KDbCursor.h
--- a/src/KDbCursor.h
+++ b/src/KDbCursor.h
@@ -69,11 +69,12 @@
 {
     Q_DECLARE_TR_FUNCTIONS(KDbCursor)
 public:
-    //! KDbCursor options that describes its behavior
-    enum Options {
-        NoOptions = 0,
+    //! Options that describe behavior of database cursor
+    enum class Option {
+        None = 0,
         Buffered = 1
     };
+    Q_DECLARE_FLAGS(Options, Option)
 
     /*! @return connection used for the cursor */
     KDbConnection* connection() const;
@@ -105,9 +106,8 @@
      or null string if raw statement instead (but KDbQuerySchema is defined instead). */
     KDbEscapedString rawSql() const;
 
-    /*! @return logically or'd cursor's options,
-      selected from KDbCursor::Options enum. */
-    int options() const;
+    /*! @return cursor options */
+    Options options() const;
 
     /*! @return true if the cursor is opened. */
     bool isOpened() const;
@@ -230,10 +230,10 @@
 
 protected:
     /*! Cursor will operate on @a conn, raw SQL statement @a sql will be used to execute query. */
-    KDbCursor(KDbConnection* conn, const KDbEscapedString& sql, int options = NoOptions);
+    KDbCursor(KDbConnection* conn, const KDbEscapedString& sql, Options options = KDbCursor::Option::None);
 
     /*! Cursor will operate on @a conn, @a query schema will be used to execute query. */
-    KDbCursor(KDbConnection* conn, KDbQuerySchema* query, int options = NoOptions);
+    KDbCursor(KDbConnection* conn, KDbQuerySchema* query, Options options = KDbCursor::Option::None);
 
     virtual ~KDbCursor();
 
@@ -298,7 +298,7 @@
                                   //!< (e.g. PostgreSQL driver, when m_containsRecordIdInfo is true
                                   //!< sets m_fieldCount+1 here)
     int m_logicalFieldCount;  //!< logical field count, i.e. without intrernal values like Record Id or lookup
-    int m_options; //!< cursor options that describes its behavior
+    KDbCursor::Options m_options; //!< cursor options that describes its behavior
 
     //! possible results of record fetching, used for m_fetchResult
     enum FetchResult {
@@ -330,4 +330,6 @@
 //! Sends information about object @a cursor to debug output @a dbg.
 KDB_EXPORT QDebug operator<<(QDebug dbg, const KDbCursor& cursor);
 
+Q_DECLARE_OPERATORS_FOR_FLAGS(KDbCursor::Options)
+
 #endif
diff --git a/src/KDbCursor.cpp b/src/KDbCursor.cpp
--- a/src/KDbCursor.cpp
+++ b/src/KDbCursor.cpp
@@ -66,7 +66,7 @@
     //</members related to buffering>
 };
 
-KDbCursor::KDbCursor(KDbConnection* conn, const KDbEscapedString& sql, int options)
+KDbCursor::KDbCursor(KDbConnection* conn, const KDbEscapedString& sql, Options options)
         : m_query(0)
         , m_options(options)
         , d(new Private)
@@ -78,7 +78,7 @@
     d->rawSql = sql;
 }
 
-KDbCursor::KDbCursor(KDbConnection* conn, KDbQuerySchema* query, int options)
+KDbCursor::KDbCursor(KDbConnection* conn, KDbQuerySchema* query, Options options)
         : m_query(query)
         , m_options(options)
         , d(new Private)
@@ -163,7 +163,7 @@
     return d->rawSql;
 }
 
-int KDbCursor::options() const
+KDbCursor::Options KDbCursor::options() const
 {
     return m_options;
 }
@@ -284,7 +284,7 @@
         return false;
     }
     if (!d->readAhead) {
-        if (m_options & Buffered) {
+        if (m_options & KDbCursor::Option::Buffered) {
             if (m_records_in_buf == 0 && m_buffering_completed) {
                 //eof and bof should now return true:
                 m_afterLast = true;
@@ -357,7 +357,7 @@
 
 bool KDbCursor::movePrev()
 {
-    if (!d->opened /*|| m_beforeFirst*/ || !(m_options & Buffered)) {
+    if (!d->opened /*|| m_beforeFirst*/ || !(m_options & KDbCursor::Option::Buffered)) {
         return false;
     }
     //we're after last record and there are records in the buffer
@@ -393,7 +393,7 @@
 
 bool KDbCursor::isBuffered() const
 {
-    return m_options & Buffered;
+    return m_options & KDbCursor::Option::Buffered;
 }
 
 void KDbCursor::setBuffered(bool buffered)
@@ -403,7 +403,7 @@
     }
     if (isBuffered() == buffered)
         return;
-    m_options ^= Buffered;
+    m_options ^= KDbCursor::Option::Buffered;
 }
 
 void KDbCursor::clearBuffer()
@@ -421,7 +421,7 @@
 {
     m_fetchResult = FetchInvalid; //by default: invalid result of record fetching
 
-    if (m_options & Buffered) {//this cursor is buffered:
+    if (m_options & KDbCursor::Option::Buffered) {//this cursor is buffered:
 //  kdbDebug() << "m_at < m_records_in_buf :: " << (long)m_at << " < " << m_records_in_buf;
         if (m_at < m_records_in_buf) {//we have next record already buffered:
             if (d->atBuffer) {//we already have got a pointer to buffer
diff --git a/src/drivers/mysql/MysqlConnection.h b/src/drivers/mysql/MysqlConnection.h
--- a/src/drivers/mysql/MysqlConnection.h
+++ b/src/drivers/mysql/MysqlConnection.h
@@ -36,8 +36,10 @@
 public:
     virtual ~MysqlConnection();
 
-    KDbCursor* prepareQuery(const KDbEscapedString& sql, int cursor_options = 0) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
-    KDbCursor* prepareQuery(KDbQuerySchema* query, int cursor_options = 0) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
+    KDbCursor* prepareQuery(const KDbEscapedString& sql,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
+    KDbCursor* prepareQuery(KDbQuerySchema* query,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
 
     KDbPreparedStatementInterface* prepareStatementInternal() Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
 
diff --git a/src/drivers/mysql/MysqlConnection.cpp b/src/drivers/mysql/MysqlConnection.cpp
--- a/src/drivers/mysql/MysqlConnection.cpp
+++ b/src/drivers/mysql/MysqlConnection.cpp
@@ -92,14 +92,14 @@
     return d->db_disconnect();
 }
 
-KDbCursor* MysqlConnection::prepareQuery(const KDbEscapedString& sql, int cursor_options)
+KDbCursor* MysqlConnection::prepareQuery(const KDbEscapedString& sql, KDbCursor::Options options)
 {
-    return new MysqlCursor(this, sql, cursor_options);
+    return new MysqlCursor(this, sql, options);
 }
 
-KDbCursor* MysqlConnection::prepareQuery(KDbQuerySchema* query, int cursor_options)
+KDbCursor* MysqlConnection::prepareQuery(KDbQuerySchema* query, KDbCursor::Options options)
 {
-    return new MysqlCursor(this, query, cursor_options);
+    return new MysqlCursor(this, query, options);
 }
 
 bool MysqlConnection::drv_getDatabasesList(QStringList* list)
diff --git a/src/drivers/mysql/MysqlCursor.h b/src/drivers/mysql/MysqlCursor.h
--- a/src/drivers/mysql/MysqlCursor.h
+++ b/src/drivers/mysql/MysqlCursor.h
@@ -30,8 +30,9 @@
 {
 public:
     MysqlCursor(KDbConnection* conn, const KDbEscapedString& sql,
-                int cursor_options = NoOptions);
-    MysqlCursor(KDbConnection* conn, KDbQuerySchema* query, int options = NoOptions);
+                KDbCursor::Options options = KDbCursor::Option::None);
+    MysqlCursor(KDbConnection* conn, KDbQuerySchema* query,
+                KDbCursor::Options options = KDbCursor::Option::None);
     virtual ~MysqlCursor();
 
     virtual QVariant value(int pos);
diff --git a/src/drivers/mysql/MysqlCursor.cpp b/src/drivers/mysql/MysqlCursor.cpp
--- a/src/drivers/mysql/MysqlCursor.cpp
+++ b/src/drivers/mysql/MysqlCursor.cpp
@@ -29,18 +29,17 @@
 
 #define BOOL bool
 
-MysqlCursor::MysqlCursor(KDbConnection* conn, const KDbEscapedString& sql, int cursor_options)
-        : KDbCursor(conn, sql, cursor_options)
+MysqlCursor::MysqlCursor(KDbConnection* conn, const KDbEscapedString& sql,
+                         KDbCursor::Options options)
+        : KDbCursor(conn, sql, options | KDbCursor::Option::Buffered)
         , d(new MysqlCursorData(conn))
 {
-    m_options |= Buffered;
 }
 
-MysqlCursor::MysqlCursor(KDbConnection* conn, KDbQuerySchema* query, int options)
-        : KDbCursor(conn, query, options)
+MysqlCursor::MysqlCursor(KDbConnection* conn, KDbQuerySchema* query, KDbCursor::Options options)
+        : KDbCursor(conn, query, options | KDbCursor::Option::Buffered)
         , d(new MysqlCursorData(conn))
 {
-    m_options |= Buffered;
 }
 
 MysqlCursor::~MysqlCursor()
diff --git a/src/drivers/postgresql/PostgresqlConnection.h b/src/drivers/postgresql/PostgresqlConnection.h
--- a/src/drivers/postgresql/PostgresqlConnection.h
+++ b/src/drivers/postgresql/PostgresqlConnection.h
@@ -44,10 +44,12 @@
     virtual ~PostgresqlConnection();
 
     //! @return a new query based on a query statement
-    KDbCursor* prepareQuery(const KDbEscapedString& sql, int cursor_options = 0) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
+    KDbCursor* prepareQuery(const KDbEscapedString& sql,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
 
     //! @return a new query based on a query object
-    KDbCursor* prepareQuery(KDbQuerySchema* query, int cursor_options = 0) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
+    KDbCursor* prepareQuery(KDbQuerySchema* query,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
 
     KDbPreparedStatementInterface* prepareStatementInternal() Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
 
diff --git a/src/drivers/postgresql/PostgresqlConnection.cpp b/src/drivers/postgresql/PostgresqlConnection.cpp
--- a/src/drivers/postgresql/PostgresqlConnection.cpp
+++ b/src/drivers/postgresql/PostgresqlConnection.cpp
@@ -64,16 +64,14 @@
     delete d;
 }
 
-KDbCursor* PostgresqlConnection::prepareQuery(const KDbEscapedString& sql,  int cursor_options)
+KDbCursor* PostgresqlConnection::prepareQuery(const KDbEscapedString& sql, KDbCursor::Options options)
 {
-    Q_UNUSED(cursor_options);
-    return new PostgresqlCursor(this, sql, 1); //Always used buffered cursor
+    return new PostgresqlCursor(this, sql, options);
 }
 
-KDbCursor* PostgresqlConnection::prepareQuery(KDbQuerySchema* query, int cursor_options)
+KDbCursor* PostgresqlConnection::prepareQuery(KDbQuerySchema* query, KDbCursor::Options options)
 {
-    Q_UNUSED(cursor_options);
-    return new PostgresqlCursor(this, query, 1);//Always used buffered cursor
+    return new PostgresqlCursor(this, query, options);
 }
 
 bool PostgresqlConnection::drv_connect()
diff --git a/src/drivers/postgresql/PostgresqlCursor.h b/src/drivers/postgresql/PostgresqlCursor.h
--- a/src/drivers/postgresql/PostgresqlCursor.h
+++ b/src/drivers/postgresql/PostgresqlCursor.h
@@ -33,8 +33,9 @@
 {
 public:
     explicit PostgresqlCursor(KDbConnection* conn, const KDbEscapedString& sql,
-                              int options = NoOptions);
-    PostgresqlCursor(KDbConnection* conn, KDbQuerySchema* query, int options = NoOptions);
+                              KDbCursor::Options options = KDbCursor::Option::None);
+    PostgresqlCursor(KDbConnection* conn, KDbQuerySchema* query,
+                     KDbCursor::Options options = KDbCursor::Option::None);
     virtual ~PostgresqlCursor();
 
     virtual QVariant value(int pos);
diff --git a/src/drivers/postgresql/PostgresqlCursor.cpp b/src/drivers/postgresql/PostgresqlCursor.cpp
--- a/src/drivers/postgresql/PostgresqlCursor.cpp
+++ b/src/drivers/postgresql/PostgresqlCursor.cpp
@@ -29,22 +29,22 @@
 #include "KDbRecordData.h"
 
 // Constructor based on query statement
-PostgresqlCursor::PostgresqlCursor(KDbConnection* conn, const KDbEscapedString& sql, int options)
-        : KDbCursor(conn, sql, options)
+PostgresqlCursor::PostgresqlCursor(KDbConnection* conn, const KDbEscapedString& sql,
+                                   KDbCursor::Options options)
+        : KDbCursor(conn, sql, options | KDbCursor::Option::Buffered)
         , m_numRows(0)
         , d(new PostgresqlCursorData(conn))
 {
-    m_options |= Buffered;
 }
 
 //==================================================================================
 //Constructor base on query object
-PostgresqlCursor::PostgresqlCursor(KDbConnection* conn, KDbQuerySchema* query, int options)
-        : KDbCursor(conn, query, options)
+PostgresqlCursor::PostgresqlCursor(KDbConnection* conn, KDbQuerySchema* query,
+                                   KDbCursor::Options options)
+        : KDbCursor(conn, query, options | KDbCursor::Option::Buffered)
         , m_numRows(0)
         , d(new PostgresqlCursorData(conn))
 {
-    m_options |= Buffered;
 }
 
 //==================================================================================
diff --git a/src/drivers/sqlite/SqliteConnection.h b/src/drivers/sqlite/SqliteConnection.h
--- a/src/drivers/sqlite/SqliteConnection.h
+++ b/src/drivers/sqlite/SqliteConnection.h
@@ -39,8 +39,10 @@
 public:
     virtual ~SqliteConnection();
 
-    KDbCursor* prepareQuery(const KDbEscapedString& sql, int cursor_options = 0) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
-    KDbCursor* prepareQuery(KDbQuerySchema* query, int cursor_options = 0) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
+    KDbCursor* prepareQuery(const KDbEscapedString& sql,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
+    KDbCursor* prepareQuery(KDbQuerySchema* query,
+                            KDbCursor::Options options = KDbCursor::Option::None) Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
 
     KDbPreparedStatementInterface* prepareStatementInternal() Q_DECL_OVERRIDE Q_REQUIRED_RESULT;
 
diff --git a/src/drivers/sqlite/SqliteConnection.cpp b/src/drivers/sqlite/SqliteConnection.cpp
--- a/src/drivers/sqlite/SqliteConnection.cpp
+++ b/src/drivers/sqlite/SqliteConnection.cpp
@@ -279,14 +279,14 @@
     return true;
 }
 
-KDbCursor* SqliteConnection::prepareQuery(const KDbEscapedString& sql, int cursor_options)
+KDbCursor* SqliteConnection::prepareQuery(const KDbEscapedString& sql, KDbCursor::Options options)
 {
-    return new SqliteCursor(this, sql, cursor_options);
+    return new SqliteCursor(this, sql, options);
 }
 
-KDbCursor* SqliteConnection::prepareQuery(KDbQuerySchema* query, int cursor_options)
+KDbCursor* SqliteConnection::prepareQuery(KDbQuerySchema* query, KDbCursor::Options options)
 {
-    return new SqliteCursor(this, query, cursor_options);
+    return new SqliteCursor(this, query, options);
 }
 
 KDbSqlResult* SqliteConnection::drv_executeSQL(const KDbEscapedString& sql)
diff --git a/src/drivers/sqlite/SqliteCursor.h b/src/drivers/sqlite/SqliteCursor.h
--- a/src/drivers/sqlite/SqliteCursor.h
+++ b/src/drivers/sqlite/SqliteCursor.h
@@ -48,11 +48,12 @@
 
 protected:
     /*! KDbCursor will operate on @a conn, raw @a sql statement will be used to execute query. */
-    SqliteCursor(SqliteConnection* conn, const KDbEscapedString& sql, int options = NoOptions);
+    SqliteCursor(SqliteConnection* conn, const KDbEscapedString& sql,
+                 Options options = KDbCursor::Option::None);
 
     /*! KDbCursor will operate on @a conn, @a query schema will be used to execute query. */
     SqliteCursor(SqliteConnection* conn, KDbQuerySchema* query,
-                 int options = NoOptions);
+                 Options options = KDbCursor::Option::None);
 
     virtual bool drv_open(const KDbEscapedString& sql);
 
diff --git a/src/drivers/sqlite/SqliteCursor.cpp b/src/drivers/sqlite/SqliteCursor.cpp
--- a/src/drivers/sqlite/SqliteCursor.cpp
+++ b/src/drivers/sqlite/SqliteCursor.cpp
@@ -143,14 +143,15 @@
     Q_DISABLE_COPY(SqliteCursorData)
 };
 
-SqliteCursor::SqliteCursor(SqliteConnection* conn, const KDbEscapedString& sql, int options)
+SqliteCursor::SqliteCursor(SqliteConnection* conn, const KDbEscapedString& sql,
+                           Options options)
         : KDbCursor(conn, sql, options)
         , d(new SqliteCursorData(conn))
 {
     d->data = static_cast<SqliteConnection*>(conn)->d->data;
 }
 
-SqliteCursor::SqliteCursor(SqliteConnection* conn, KDbQuerySchema* query, int options)
+SqliteCursor::SqliteCursor(SqliteConnection* conn, KDbQuerySchema* query, Options options)
         : KDbCursor(conn, query, options)
         , d(new SqliteCursorData(conn))
 {
diff --git a/tests/features/main.cpp b/tests/features/main.cpp
--- a/tests/features/main.cpp
+++ b/tests/features/main.cpp
@@ -40,7 +40,7 @@
 QString db_name;
 QString drv_id;
 QString test_name;
-int cursor_options = 0;
+KDbCursor::Options cursor_options;
 bool db_name_required = true;
 
 KDbConnectionData conn_data;
@@ -288,7 +288,7 @@
     if (!db_name.isEmpty() ) {
         //additional switches:
         if (bufCursors) {
-            cursor_options |= KDbCursor::Buffered;
+            cursor_options |= KDbCursor::Option::Buffered;
         }
         conn = driver->createConnection(conn_data);