[libgdamm] Statement::to_sql(), Connection::statement*(): const corrections.

[Murray Cumming <murrayc src gnome org>]

commit 2b9d5296eeb609d530a038913672b557049fdce2
Author: Murray Cumming <murrayc murrayc com>
Date:   Sun Oct 25 19:17:14 2009 +0100

    Statement::to_sql(), Connection::statement*(): const corrections.
    
    	* libgda/src/statement.[hg|ccg|: to_sql(): Make the params parameter const.
    	* libgda/src/connection.[hg|ccg|: statement_execute*(), statement_to_sql():
    	Make the statement and params parameters const.

 ChangeLog                    |    8 ++++++
 libgda/src/connection.ccg    |   54 +++++++++++++++++++++---------------------
 libgda/src/connection.hg     |   38 ++++++++++++++--------------
 libgda/src/statement.ccg     |   12 ++++----
 libgda/src/statement.hg      |    8 +++---
 tools/m4/convert_libgdamm.m4 |    1 +
 6 files changed, 65 insertions(+), 56 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 524a0f9..8b15816 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,13 @@
 2009-10-25  Murray Cumming  <murrayc murrayc com>
 
+  Statement::to_sql(), Connection::statement*(): const corrections.
+  
+	* libgda/src/statement.[hg|ccg|: to_sql(): Make the params parameter const.
+  * libgda/src/connection.[hg|ccg|: statement_execute*(), statement_to_sql():
+  Make the statement and params parameters const.
+
+2009-10-25  Murray Cumming  <murrayc murrayc com>
+
   SqlBuilder: Small const and other improvements.
   
 	* libgda/src/sqlbuilder.[hg|ccg]: add_expr(): Use const ref for the Value 
diff --git a/libgda/src/connection.ccg b/libgda/src/connection.ccg
index a4aa6b8..575ba3e 100644
--- a/libgda/src/connection.ccg
+++ b/libgda/src/connection.ccg
@@ -83,15 +83,15 @@ void Connection::close()
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<Statement>& cmd, const Glib::RefPtr<Set>& params, StatementModelUsage model_usage, Glib::RefPtr<Set>& last_inserted_row)
+Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& cmd, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, Glib::RefPtr<const Set>& last_inserted_row)
 #else
-Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<Statement>& cmd, const Glib::RefPtr<Set>& params, StatementModelUsage model_usage, Glib::RefPtr<Set>& last_inserted_row, std::auto_ptr<Glib::Error>& error)
+Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& cmd, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, Glib::RefPtr<const Set>& last_inserted_row, std::auto_ptr<Glib::Error>& error)
 #endif // GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
   GdaSet* lir = 0;
   Glib::RefPtr<Glib::Object> retval = Glib::wrap(
-    gda_connection_statement_execute(gobj(), cmd->gobj(), Glib::unwrap(params), (GdaStatementModelUsage)model_usage, &lir, &gerror));
+    gda_connection_statement_execute(gobj(), const_cast<GdaStatement*>(cmd->gobj()), const_cast<GdaSet*>(Glib::unwrap(params)), (GdaStatementModelUsage)model_usage, &lir, &gerror));
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
@@ -108,14 +108,14 @@ Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<Stat
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage)
+Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage)
 #else
-Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
+Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
 #endif // GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
   Glib::RefPtr<Glib::Object> retval = Glib::wrap(
-    gda_connection_statement_execute(gobj(), Glib::unwrap(stmt), 0, (GdaStatementModelUsage)model_usage, 0, &gerror));
+    gda_connection_statement_execute(gobj(), const_cast<GdaStatement*>(Glib::unwrap(stmt)), 0, (GdaStatementModelUsage)model_usage, 0, &gerror));
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
@@ -134,7 +134,7 @@ Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::ustring& sq
 Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::ustring& sql, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
 #endif // GLIBMM_EXCEPTIONS_ENABLED
 {
-  Glib::RefPtr<Statement> stmt;
+  Glib::RefPtr<const Statement> stmt;
   Glib::RefPtr<SqlParser> parser = create_parser();
   if(parser)
   {
@@ -160,14 +160,14 @@ Glib::RefPtr<Glib::Object> Connection::statement_execute(const Glib::ustring& sq
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd, const Glib::RefPtr<Set>& params, Glib::RefPtr<Set>& last_inserted_row)
+int Connection::statement_execute_non_select(const Glib::RefPtr<const Statement>& cmd, const Glib::RefPtr<const Set>& params, Glib::RefPtr<const Set>& last_inserted_row)
 #else
-int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd, const Glib::RefPtr<Set>& params, Glib::RefPtr<Set>& last_inserted_row, std::auto_ptr<Glib::Error>& error)
+int Connection::statement_execute_non_select(const Glib::RefPtr<const Statement>& cmd, const Glib::RefPtr<const Set>& params, Glib::RefPtr<const Set>& last_inserted_row, std::auto_ptr<Glib::Error>& error)
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
   GdaSet* lir = 0;
-  const int retval = gda_connection_statement_execute_non_select(gobj(), Glib::unwrap(cmd), Glib::unwrap(params), &lir, &gerror);
+  const int retval = gda_connection_statement_execute_non_select(gobj(), const_cast<GdaStatement*>(Glib::unwrap(cmd)),  const_cast<GdaSet*>(Glib::unwrap(params)), &lir, &gerror);
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
@@ -184,13 +184,13 @@ int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd,
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd, const Glib::RefPtr<Set>& params)
+int Connection::statement_execute_non_select(const Glib::RefPtr<const Statement>& cmd, const Glib::RefPtr<const Set>& params)
 #else
-int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd, const Glib::RefPtr<Set>& params, std::auto_ptr<Glib::Error>& error)
+int Connection::statement_execute_non_select(const Glib::RefPtr<const Statement>& cmd, const Glib::RefPtr<const Set>& params, std::auto_ptr<Glib::Error>& error)
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
-  const int retval = gda_connection_statement_execute_non_select(gobj(), Glib::unwrap(cmd), Glib::unwrap(params), 0, &gerror);
+  const int retval = gda_connection_statement_execute_non_select(gobj(), const_cast<GdaStatement*>(Glib::unwrap(cmd)),  const_cast<GdaSet*>(Glib::unwrap(params)), 0, &gerror);
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
@@ -204,13 +204,13 @@ int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd,
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd)
+int Connection::statement_execute_non_select(const Glib::RefPtr<const Statement>& cmd)
 #else
-int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd, std::auto_ptr<Glib::Error>& error)
+int Connection::statement_execute_non_select(const Glib::RefPtr<const Statement>& cmd, std::auto_ptr<Glib::Error>& error)
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
-  int retval = gda_connection_statement_execute_non_select(gobj(), Glib::unwrap(cmd), 0, 0, &gerror);
+  int retval = gda_connection_statement_execute_non_select(gobj(), const_cast<GdaStatement*>(Glib::unwrap(cmd)), 0, 0, &gerror);
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
     ::Glib::Error::throw_exception(gerror);
@@ -223,14 +223,14 @@ int Connection::statement_execute_non_select(const Glib::RefPtr<Statement>& cmd,
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<Statement>& statement, const Glib::RefPtr<Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used)
+Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, const Glib::RefPtr<const Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used)
 #else
-Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<Statement>& statement, const Glib::RefPtr<Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used, std::auto_ptr<Glib::Error>& error)
+Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<const Statement>& statement, const Glib::RefPtr<const Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used, std::auto_ptr<Glib::Error>& error)
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
-  GSList* params_usedc = NULL;
-  const Glib::ustring retvalue = Glib::convert_return_gchar_ptr_to_ustring(gda_connection_statement_to_sql(gobj(), Glib::unwrap(statement), Glib::unwrap(params), ((GdaStatementSqlFlag)(flags)), &params_usedc, &(gerror)));
+  GSList* params_usedc = 0;
+  const Glib::ustring retvalue = Glib::convert_return_gchar_ptr_to_ustring(gda_connection_statement_to_sql(gobj(), const_cast<GdaStatement*>(Glib::unwrap(statement)), const_cast<GdaSet*>(Glib::unwrap(params)), ((GdaStatementSqlFlag)(flags)), &params_usedc, &(gerror)));
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
@@ -252,13 +252,13 @@ Glib::ustring Connection::statement_to_sql(const Glib::RefPtr<Statement>& statem
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage)
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage)
 #else
-Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
 #endif
 {
   GError* gerror = 0;
-  Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_statement_execute_select_full(gobj(), Glib::unwrap(stmt), NULL /* params */, ((GdaStatementModelUsage)(model_usage)), NULL /* col_types */, &(gerror)));
+  Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_statement_execute_select_full(gobj(), const_cast<GdaStatement*>(Glib::unwrap(stmt)), 0 /* params */, ((GdaStatementModelUsage)(model_usage)), 0 /* col_types */, &(gerror)));
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
     ::Glib::Error::throw_exception(gerror);
@@ -276,7 +276,7 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring
 Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
 #endif // GLIBMM_EXCEPTIONS_ENABLED
 {
-  Glib::RefPtr<Statement> stmt;
+  Glib::RefPtr<const Statement> stmt;
   Glib::RefPtr<SqlParser> parser = create_parser();
   if(parser)
   {
@@ -293,7 +293,7 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring
     return Glib::RefPtr<DataModel>();
 
   GError* gerror = 0;
-  Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_statement_execute_select_full(gobj(), Glib::unwrap(stmt), NULL /* params */, ((GdaStatementModelUsage)(model_usage)), NULL /* col_types */, &(gerror)));
+  Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_statement_execute_select_full(gobj(), const_cast<GdaStatement*>(Glib::unwrap(stmt)), 0 /* params */, ((GdaStatementModelUsage)(model_usage)), 0 /* col_types */, &(gerror)));
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
     ::Glib::Error::throw_exception(gerror);
@@ -332,7 +332,7 @@ bool Connection::update_meta_store(const Glib::ustring& id, std::auto_ptr<Glib::
 #endif
 {
   GError* gerror = 0;
-  GdaMetaContext mcontext = {const_cast<gchar*>(id.c_str()), 1, NULL, NULL};
+  GdaMetaContext mcontext = {const_cast<gchar*>(id.c_str()), 1, 0, 0};
   const bool retvalue = gda_connection_update_meta_store(gobj(), &mcontext, &gerror);
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
@@ -352,7 +352,7 @@ Glib::RefPtr<DataModel> Connection::get_meta_store_data(ConnectionMetaType meta_
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
-  Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_get_meta_store_data_v(gobj(), ((GdaConnectionMetaType)(meta_type)), NULL, &(gerror)));
+  Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_get_meta_store_data_v(gobj(), ((GdaConnectionMetaType)(meta_type)), 0, &(gerror)));
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
     ::Glib::Error::throw_exception(gerror);
diff --git a/libgda/src/connection.hg b/libgda/src/connection.hg
index b902342..79b12af 100644
--- a/libgda/src/connection.hg
+++ b/libgda/src/connection.hg
@@ -116,16 +116,16 @@ public:
   _WRAP_METHOD_DOCS_ONLY(gda_connection_statement_execute)
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params, StatementModelUsage model_usage, Glib::RefPtr<Set>& last_insert_row);
+  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, Glib::RefPtr<const Set>& last_insert_row);
 #else
-  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params, StatementModelUsage model_usage, Glib::RefPtr<Set>& last_insert_row, std::auto_ptr<Glib::Error>& error);
+  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, Glib::RefPtr<const Set>& last_insert_row, std::auto_ptr<Glib::Error>& error);
 #endif // GLIBMM_EXCEPTIONS_ENABLED
 
 //TODO: Documentation:
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
+  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
 #else
-  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
+  Glib::RefPtr<Glib::Object> statement_execute(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
 #endif // GLIBMM_EXCEPTIONS_ENABLED
 
 
@@ -135,19 +135,19 @@ public:
   Glib::RefPtr<Glib::Object> statement_execute(const Glib::ustring& sql, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
 #endif // GLIBMM_EXCEPTIONS_ENABLED
   
-  _WRAP_METHOD(Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params), gda_connection_statement_execute_select, errthrow)
+  _WRAP_METHOD(Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params), gda_connection_statement_execute_select, errthrow)
 
 //TODO: Documentation:
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
   Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
 #else
-  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
   Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
 #endif
 
   #m4 _CONVERSION(`const Glib::ArrayHandle<GType>&', `GType*', `const_cast<GType*>(($3).data())')
-  _WRAP_METHOD(Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params, StatementModelUsage model_usage, const Glib::ArrayHandle<GType>& col_types), gda_connection_statement_execute_select_full, errthrow)
+  _WRAP_METHOD(Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, const Glib::ArrayHandle<GType>& col_types), gda_connection_statement_execute_select_full, errthrow)
   _IGNORE(gda_connection_statement_execute_select_fullv)
   
   _WRAP_METHOD_DOCS_ONLY(gda_connection_statement_execute_non_select)
@@ -156,23 +156,23 @@ public:
 //TODO: Documentation:
 //TODO: It's not nice that these two method overloads differ only by the constness of the set.
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  int statement_execute_non_select(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params, Glib::RefPtr<Set>& last_insert_row);
+  int statement_execute_non_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, Glib::RefPtr<const Set>& last_insert_row);
 #else
-  int statement_execute_non_select(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params, Glib::RefPtr<Set>& last_insert_row, std::auto_ptr<Glib::Error>& error);
+  int statement_execute_non_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, Glib::RefPtr<const Set>& last_insert_row, std::auto_ptr<Glib::Error>& error);
 #endif //GLIBMM_EXCEPTIONS_ENABLED  
 
 //TODO: Documentation:
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  int statement_execute_non_select(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params);
+  int statement_execute_non_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params);
 #else
-  int statement_execute_non_select(const Glib::RefPtr<Statement>& stmt,  const Glib::RefPtr<Set>& params, std::auto_ptr<Glib::Error>& error);
+  int statement_execute_non_select(const Glib::RefPtr<const Statement>& stmt,  const Glib::RefPtr<const Set>& params, std::auto_ptr<Glib::Error>& error);
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 
 //TODO: Documentation:
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  int statement_execute_non_select(const Glib::RefPtr<Statement>& stmt);
+  int statement_execute_non_select(const Glib::RefPtr<const Statement>& stmt);
 #else
-  int statement_execute_non_select(const Glib::RefPtr<Statement>& stmt, std::auto_ptr<Glib::Error>& error);
+  int statement_execute_non_select(const Glib::RefPtr<const Statement>& stmt, std::auto_ptr<Glib::Error>& error);
 #endif //GLIBMM_EXCEPTIONS_ENABLED
   
   _WRAP_METHOD(int statement_execute_non_select(const Glib::ustring& sql), gda_execute_non_select_command, errthrow)
@@ -283,7 +283,7 @@ public:
   bool update_meta_store_data_types(std::auto_ptr<Glib::Error>& err);
 #endif //GLIBMM_EXCEPTIONS_ENABLED
   
-  _WRAP_METHOD(bool statement_prepare(const Glib::RefPtr<Statement>& stmt), gda_connection_statement_prepare, errthrow)
+  _WRAP_METHOD(bool statement_prepare(const Glib::RefPtr<const Statement>& stmt), gda_connection_statement_prepare, errthrow)
 
 
   #m4 _CONVERSION(`const Glib::ListHandle< Glib::RefPtr<Holder> >&',`GList*',`$3.data()')
@@ -300,8 +300,8 @@ public:
   _WRAP_METHOD(Glib::RefPtr<const MetaStore> get_meta_store() const, gda_connection_get_meta_store, constversion)
 
   #m4 _CONVERSION(`GSList*',`Glib::SListHandle< Glib::RefPtr<Glib::Object> >',`$2((GSList*)$3, Glib::OWNERSHIP_SHALLOW)')
-  _WRAP_METHOD(Glib::SListHandle< Glib::RefPtr<Glib::Object> > batch_execute(const Glib::RefPtr<Batch>& batch, const Glib::RefPtr<Set>& params, StatementModelUsage model_usage), gda_connection_batch_execute, errthrow)
-  _WRAP_METHOD(Glib::RefPtr<ServerOperation> create_operation(ServerOperationType type, const Glib::RefPtr<Set>& options), gda_connection_create_operation, errthrow)
+  _WRAP_METHOD(Glib::SListHandle< Glib::RefPtr<Glib::Object> > batch_execute(const Glib::RefPtr<Batch>& batch, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage), gda_connection_batch_execute, errthrow)
+  _WRAP_METHOD(Glib::RefPtr<ServerOperation> create_operation(ServerOperationType type, const Glib::RefPtr<const Set>& options), gda_connection_create_operation, errthrow)
   _WRAP_METHOD(bool perform_operation(const Glib::RefPtr<ServerOperation>& op), gda_connection_perform_operation, errthrow)
 
   _WRAP_METHOD(Glib::RefPtr<ServerProvider> get_provider(), gda_connection_get_provider, refreturn)
@@ -311,9 +311,9 @@ public:
 
   //TODO: Add an overload without the params_used.
   #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::ustring statement_to_sql(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used);
+  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used);
   #else
-  Glib::ustring statement_to_sql(const Glib::RefPtr<Statement>& stmt, const Glib::RefPtr<Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used, std::auto_ptr<Glib::Error>& error);
+  Glib::ustring statement_to_sql(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementSqlFlag flags, std::list< Glib::RefPtr<Holder> >& params_used, std::auto_ptr<Glib::Error>& error);
   #endif //GLIBMM_EXCEPTIONS_ENABLED
     
   #m4 _CONVERSION(`GdaConnectionEvent*',`const Glib::RefPtr<ConnectionEvent>&',Glib::wrap($3, true))
diff --git a/libgda/src/statement.ccg b/libgda/src/statement.ccg
index 8a1aa77..223e694 100644
--- a/libgda/src/statement.ccg
+++ b/libgda/src/statement.ccg
@@ -80,15 +80,15 @@ Glib::ustring Statement::to_sql(std::auto_ptr<Glib::Error>& error) const
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::ustring Statement::to_sql(const Glib::RefPtr<Set>& params) const
+Glib::ustring Statement::to_sql(const Glib::RefPtr<const Set>& params) const
 #else
-Glib::ustring Statement::to_sql(const Glib::RefPtr<Set>& params, std::auto_ptr<Glib::Error>& error) const
+Glib::ustring Statement::to_sql(const Glib::RefPtr<const Set>& params, std::auto_ptr<Glib::Error>& error) const
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
   const Glib::ustring retval = 
     Glib::convert_return_gchar_ptr_to_ustring(
-      gda_statement_to_sql(const_cast<GdaStatement*>(gobj()), Glib::unwrap(params), &gerror));
+      gda_statement_to_sql(const_cast<GdaStatement*>(gobj()), const_cast<GdaSet*>(Glib::unwrap(params)), &gerror));
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
     ::Glib::Error::throw_exception(gerror);
@@ -100,10 +100,10 @@ Glib::ustring Statement::to_sql(const Glib::RefPtr<Set>& params, std::auto_ptr<G
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-Glib::ustring Statement::to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<Set>& params, 
+Glib::ustring Statement::to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<const Set>& params, 
                               StatementSqlFlag flags, const HolderSList&) const
 #else
-Glib::ustring Statement::to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<Set>& params, 
+Glib::ustring Statement::to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<const Set>& params, 
                               StatementSqlFlag flags, const HolderSList&,
                               std::auto_ptr<Glib::Error>& error) const
 #endif //GLIBMM_EXCEPTIONS_ENABLED
@@ -112,7 +112,7 @@ Glib::ustring Statement::to_sql(const Glib::RefPtr<Connection>& cnc, const Glib:
   GSList* list = 0;
   const Glib::ustring retval = 
     Glib::convert_return_gchar_ptr_to_ustring(
-      gda_statement_to_sql_extended(const_cast<GdaStatement*>(gobj()), Glib::unwrap(cnc), Glib::unwrap(params), (GdaStatementSqlFlag) flags, &list, &gerror));
+      gda_statement_to_sql_extended(const_cast<GdaStatement*>(gobj()), Glib::unwrap(cnc), const_cast<GdaSet*>(Glib::unwrap(params)), (GdaStatementSqlFlag) flags, &list, &gerror));
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
     ::Glib::Error::throw_exception(gerror);
diff --git a/libgda/src/statement.hg b/libgda/src/statement.hg
index 52b5fd9..c6ab4f1 100644
--- a/libgda/src/statement.hg
+++ b/libgda/src/statement.hg
@@ -91,9 +91,9 @@ public:
 
   //TODO: Documentation:
   #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::ustring to_sql(const Glib::RefPtr<Set>& params) const;
+  Glib::ustring to_sql(const Glib::RefPtr<const Set>& params) const;
   #else
-  Glib::ustring to_sql(const Glib::RefPtr<Set>& params, std::auto_ptr<Glib::Error>& error) const;
+  Glib::ustring to_sql(const Glib::RefPtr<const Set>& params, std::auto_ptr<Glib::Error>& error) const;
   #endif //GLIBMM_EXCEPTIONS_ENABLED
   _IGNORE(gda_statement_to_sql, gda_statement_to_sql_real)
 
@@ -102,10 +102,10 @@ public:
   //TODO: Add an overload without the params?
   _WRAP_METHOD_DOCS_ONLY(gda_statement_to_sql_extended)  
   #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  Glib::ustring to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<Set>& params, 
+  Glib::ustring to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<const Set>& params, 
                                 StatementSqlFlag flags, const HolderSList& params_used) const;
   #else
-  Glib::ustring to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<Set>& params, 
+  Glib::ustring to_sql(const Glib::RefPtr<Connection>& cnc, const Glib::RefPtr<const Set>& params, 
                                 StatementSqlFlag flags, const HolderSList& params_used,
                                 std::auto_ptr<Glib::Error>& error) const;
   #endif //GLIBMM_EXCEPTIONS_ENABLED
diff --git a/tools/m4/convert_libgdamm.m4 b/tools/m4/convert_libgdamm.m4
index 50cdc6e..42ee37e 100644
--- a/tools/m4/convert_libgdamm.m4
+++ b/tools/m4/convert_libgdamm.m4
@@ -53,6 +53,7 @@ _CONVERSION(`const Glib::RefPtr<ServerOperation>&', `GdaServerOperation*', __CON
 _CONVERSION(`const Glib::RefPtr<TransactionStatus>&', `GdaTransactionStatus*', __CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Connection>&', `GdaConnection*', __CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Statement>&', `GdaStatement*', __CONVERT_REFPTR_TO_P)
+_CONVERSION(`const Glib::RefPtr<const Statement>&', `GdaStatement*', __CONVERT_CONST_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Set>&', `GdaSet*', __CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<Holder>&', `GdaHolder*', __CONVERT_REFPTR_TO_P)
 _CONVERSION(`const Glib::RefPtr<const Set>&', `const GdaSet*', __CONVERT_REFPTR_TO_P)