Added more features to Sybase driver

Author: vimsh

README.md

@@ -5,11 +5,11 @@ This project is to create an easy to use, database agnostic, modular, and easily
 
 This is work in progress and not a production-ready code that may have bugs!
 
-Currently only prmitive Sybase driver is implemented.
+Currently only a limited featured Sybase driver is implemented, see sybase_example.cpp
 
-Any volanteers are welcomed to contribute.
+Any volunteers are welcomed to contribute.
 
 TODO:
-- add support for more features to Sybase driver
+- add support for more data types, stored procs, and cursor to Sybase driver
 - write unit tests
 - eventually add support for more databases

connection.hpp

@@ -17,7 +17,7 @@
  */
 
 #ifndef CONNECTION_HPP
-#define	CONNECTION_HPP
+#define CONNECTION_HPP
 
 #include <memory>
 #include "utilities.hpp"
@@ -44,6 +44,7 @@ struct iconnection
     virtual void disconnect() = 0;
     virtual void commit() = 0;
     virtual void rollback() = 0;
+    virtual void autocommit(bool ac) = 0;
     virtual bool connected() const = 0;
     virtual bool alive() const = 0;
     virtual istatement* get_statement(iconnection&) = 0;
@@ -63,62 +64,114 @@ struct iconnection
 class connection {
 
 public:
+    /**
+     * Move constructor
+     * @param conn
+     */
     connection(connection&& conn) : conn_impl(std::move(conn.conn_impl))
     {
     }
 
+    /**
+     * Move assign operator
+     * @param conn
+     * @return 
+     */
     connection& operator=(connection&& conn)
     {
         if (this != &conn)
             conn_impl = std::move(conn.conn_impl);
         return *this;
     }
 
+    /**
+     * Destructor
+     */
     ~connection()
     {
         disconnect();
     }
 
+    /**
+     * Function opens connection to the database
+     * @return true on success, false otherwise
+     */
     bool connect()
     {
         return conn_impl->connect();
     }
 
+    /**
+     * Function closes connection to the database
+     */
     void disconnect()
     {
         conn_impl->disconnect();
     }
 
+    /**
+     * Function sets autocommit option, default is 'true'
+     * @param ac - true to set autocommit ON, false - OFF
+     */
+    void autocommit(bool ac)
+    {
+        return conn_impl->autocommit(ac);
+    }
+
+    /**
+     * Function commits changes to the database
+     */
     void commit()
     {
         conn_impl->commit();
     }
 
+    /**
+     * Function rolls back uncommitted changes
+     */
     void rollback()
     {
         conn_impl->rollback();
     }
 
+    /**
+     * Function checks if connection to the database is opened
+     * @return true on success, false otherwise
+     */
     bool connected() const
     {
         return conn_impl->connected();
     }
 
+    /**
+     * Function checks if connection to the database is alive
+     * @return true on success, false otherwise
+     */
     bool alive() const
     {
         return conn_impl->alive();
     }
 
+    /**
+     * Function returns statement object for the connection
+     * @return 
+     */
     statement get_statement()
     {
         return statement(conn_impl->get_statement(*(conn_impl.get())));
     }
 
+    /**
+     * Conversion operator to the concrete database connection implementation
+     * @return 
+     */
     template <typename T>
-    T& get_native_connection()
+    explicit operator T&() const
     {
         return dynamic_cast<T&>(*conn_impl);
     }
+    
+    
 
 private:
     template <typename T> friend class dbd::driver;
@@ -135,5 +188,5 @@ class connection {
 
 } } } // namespace vgi::dbconn::dbi
 
-#endif	// CONNECTION_HPP
+#endif // CONNECTION_HPP
 

driver.hpp

@@ -17,7 +17,7 @@
  */
 
 #ifndef DRIVER_HPP
-#define	DRIVER_HPP
+#define DRIVER_HPP
 
 #include <memory>
 #include <functional>
@@ -68,5 +68,5 @@ class driver : public T
 
 }}} // namespace vgi::dbconn::dbd
 
-#endif	// DRIVER_HPP
+#endif // DRIVER_HPP
 

result_set.hpp

@@ -17,7 +17,7 @@
  */
 
 #ifndef RESULT_SET_HPP
-#define	RESULT_SET_HPP
+#define RESULT_SET_HPP
 
 namespace vgi { namespace dbconn { namespace dbi {
 
@@ -34,29 +34,30 @@ struct iresult_set
     virtual bool has_data() = 0;
     virtual bool more_results() = 0;
     virtual size_t row_count() const = 0;
+    virtual size_t rows_affected() const = 0;
     virtual size_t column_count() const = 0;
     virtual bool next() = 0;
-    virtual std::string column_name(size_t index) = 0;
+    virtual std::string column_name(size_t col_idx) = 0;
     virtual int column_index(const std::string& col_name) = 0;
-    virtual bool is_null(unsigned int colidx) = 0;
-    virtual int16_t get_short(unsigned int colidx) = 0;
-    virtual uint16_t get_ushort(unsigned int colidx) = 0;
-    virtual int32_t get_int(unsigned int colidx) = 0;
-    virtual uint32_t get_uint(unsigned int colidx) = 0;
-    virtual int64_t get_long(unsigned int colidx) = 0;
-    virtual uint64_t get_ulong(unsigned int colidx) = 0;
-    virtual float get_float(unsigned int colidx) = 0;
-    virtual double get_double(unsigned int colidx) = 0;
-    virtual long double get_ldouble(unsigned int colidx) = 0;
-    virtual bool get_bool(unsigned int colidx) = 0;
-    virtual char get_char(unsigned int colidx) = 0;
-    virtual std::string get_string(unsigned int colidx) = 0;
-    virtual int get_date(unsigned int colidx) = 0;
-    virtual double get_time(unsigned int colidx) = 0;
-    virtual time_t get_datetime(unsigned int colidx) = 0;
-    virtual char16_t get_unichar(unsigned int colidx) = 0;
-    virtual std::u16string get_unistring(unsigned int colidx) = 0;
-    virtual std::vector<uint8_t> get_image(unsigned int colidx) = 0;
+    virtual bool is_null(size_t col_idx) = 0;
+    virtual int16_t get_short(size_t col_idx) = 0;
+    virtual uint16_t get_ushort(size_t col_idx) = 0;
+    virtual int32_t get_int(size_t col_idx) = 0;
+    virtual uint32_t get_uint(size_t col_idx) = 0;
+    virtual int64_t get_long(size_t col_idx) = 0;
+    virtual uint64_t get_ulong(size_t col_idx) = 0;
+    virtual float get_float(size_t col_idx) = 0;
+    virtual double get_double(size_t col_idx) = 0;
+    virtual long double get_ldouble(size_t col_idx) = 0;
+    virtual bool get_bool(size_t col_idx) = 0;
+    virtual char get_char(size_t col_idx) = 0;
+    virtual std::string get_string(size_t col_idx) = 0;
+    virtual int get_date(size_t col_idx) = 0;
+    virtual double get_time(size_t col_idx) = 0;
+    virtual time_t get_datetime(size_t col_idx) = 0;
+    virtual char16_t get_unichar(size_t col_idx) = 0;
+    virtual std::u16string get_unistring(size_t col_idx) = 0;
+    virtual std::vector<uint8_t> get_image(size_t col_idx) = 0;
     // TODO: add xml, binary, money, lob
 };
 
@@ -74,75 +75,149 @@ struct iresult_set
 class result_set
 {
 public:
+    /**
+     * Copy constructor
+     * @param rs
+     */
     result_set(const result_set& rs) : rs_impl(rs.rs_impl)
     {
     }
 
+    /**
+     * Move constructor
+     * @param rs
+     */
     result_set(result_set&& rs) : rs_impl(std::move(rs.rs_impl))
     {
     }
 
+    /**
+     * Assignment copy operator
+     * @param rs
+     * @return 
+     */
     result_set& operator=(const result_set& rs)
     {
         if (this != &rs)
             rs_impl = rs.rs_impl;
         return *this;
     }
 
+    /**
+     * Assignment move operator
+     * @param rs
+     * @return 
+     */
     result_set& operator=(result_set&& rs)
     {
         if (this != &rs)
             rs_impl = std::move(rs.rs_impl);
         return *this;
     }
 
+    /**
+     * Function checks if current result set contains data.
+     * Even after whole data set has been iterated through using next() the 
+     * has_data() function would still return true - it is only reset after call
+     * to more_results() function which will close current result set.
+     * @return true if there is data in current result set, false otherwise
+     */
     bool has_data()
     {
         return rs_impl->has_data();
     }
 
+    /**
+     * Function checks if there is another data set or status.
+     * @return true if there is another result set, false otherwise
+     */
     bool more_results()
     {
         return rs_impl->more_results();
     }
 
+    /**
+     * Function returns current row count while iterating through the result set
+     * and total number of rows after data set was processed
+     */
     size_t row_count() const
     {
         return rs_impl->row_count();
     }
 
+    /**
+     * Function returns number of affected rows after execution of command 
+     * @return number of rows
+     */
+    size_t rows_affected() const
+    {
+        return rs_impl->rows_affected();
+    }
+
+    /**
+     * Function returns number of columns of current result set or zero
+     * @return number of columns or zero otherwise
+     */
     size_t column_count() const
     {
         return rs_impl->column_count();
     }
 
-    const std::string column_name(size_t index)
+    /**
+     * Function returns column name by column index or throws an exception if
+     * index is invalid 
+        * @param col_idx
+     * @return column name string or exception is thrown if index is invalid
+     */
+    const std::string column_name(size_t col_idx)
     {
-        return rs_impl->column_name(index);
+        return std::move(rs_impl->column_name(col_idx));
     }
 
+    /**
+     * Function returns column index by column name, if column name is invalid
+     * then -1 is returned
+     * @param col_name
+     * @return index or -1 on invalid column name
+     */
     int column_index(const std::string& col_name)
     {
         return rs_impl->column_index(col_name);
     }
 
+    /**
+     * Function moves iterator to the next row of the current result data set
+     * @return true on success, or false if there is no more rows
+     */
     bool next()
     {
         return rs_impl->next();
     }
 
-    bool is_null(unsigned int colidx)
+    /**
+     * Function checks if cell data is NULL by column index or throws an exception
+     * if index is invalid.
+     * @param col_idx
+     * @return true if cell data is NULL, false otherwise
+     */
+    bool is_null(size_t col_idx)
     {
-        return rs_impl->is_null(colidx);
+        return rs_impl->is_null(col_idx);
     }
 
+    /**
+     * Function checks if cell data is NULL by column name or throws an exception
+     * if index is invalid.
+     * @param colname
+     * @return 
+     */
     bool is_null(const std::string& colname)
     {
         return rs_impl->is_null(rs_impl->column_index(colname));
     }
 
-#define get_type_by_index(t)	get_##t(unsigned int colidx) { return rs_impl->get_##t(colidx); }
-#define get_type_by_name(t)	    get_##t(const std::string& colname) { return rs_impl->get_##t(rs_impl->column_index(colname)); }
+#define get_type_by_index(t) get_##t(size_t col_idx) { return rs_impl->get_##t(col_idx); }
+#define get_type_by_name(t)  get_##t(const std::string& colname) { return rs_impl->get_##t(rs_impl->column_index(colname)); }
 
     int16_t get_type_by_index(short);
     int16_t get_type_by_name(short);
@@ -193,5 +268,5 @@ class result_set
 
 } } } // namespace vgi::dbconn::dbi
 
-#endif	// RESULT_SET_HPP
+#endif // RESULT_SET_HPP