[libgdamm] Connection, SqlBuilder: Addd some convenient method overloads.

[Murray Cumming <murrayc src gnome org>]

commit bf7f04ef1447453c8a85286929fcdba064a96b02
Author: Murray Cumming <murrayc murrayc com>
Date:   Sat Feb 27 12:20:29 2010 +0100

    Connection, SqlBuilder: Addd some convenient method overloads.
    
    * libgda/src/connection.[hg|ccg]: statement_execute_select(statement, params):
    Add an optional model_usage parameter, as already exists on other method
    overloads.
    Added statement_execute_select_builder() to avoid the need to generate a
    statement from a builder.
    * libgda/src/sqlbuilder.[hg|ccg]: Added an add_function() overload that
    takes only one parameter.

 ChangeLog                 |   12 +++++
 libgda/src/connection.ccg |  112 +++++++++++++++++++++++++++++++++++++++++++-
 libgda/src/connection.hg  |   44 ++++++++++++++---
 libgda/src/sqlbuilder.ccg |    5 ++
 libgda/src/sqlbuilder.hg  |    9 ++++
 5 files changed, 171 insertions(+), 11 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index 04013b8..43652c3 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,17 @@
 2010-02-27  Murray Cumming  <murrayc murrayc com>
 
+  Connection, SqlBuilder: Addd some convenient method overloads.
+  
+	* libgda/src/connection.[hg|ccg]: statement_execute_select(statement, params):
+	Add an optional model_usage parameter, as already exists on other method 
+	overloads.
+	Added statement_execute_select_builder() to avoid the need to generate a 
+	statement from a builder.
+	* libgda/src/sqlbuilder.[hg|ccg]: Added an add_function() overload that 
+	takes only one parameter.
+
+2010-02-27  Murray Cumming  <murrayc murrayc com>
+
   SqlBuilder: Add SqlError and fix select_add_target() with no alias.
   
 	* libgda/src/sqlbuilder.[hg|ccg]: Add SqlError to wrap the GdaSqlError 
diff --git a/libgda/src/connection.ccg b/libgda/src/connection.ccg
index 575ba3e..f3f19d1 100644
--- a/libgda/src/connection.ccg
+++ b/libgda/src/connection.ccg
@@ -223,14 +223,14 @@ int Connection::statement_execute_non_select(const Glib::RefPtr<const Statement>
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
-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)
+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) const
 #else
-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)
+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) const
 #endif //GLIBMM_EXCEPTIONS_ENABLED
 {
   GError* gerror = 0;
   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)));
+  const Glib::ustring retvalue = Glib::convert_return_gchar_ptr_to_ustring(gda_connection_statement_to_sql(const_cast<GdaConnection*>(gobj()), const_cast<GdaStatement*>(Glib::unwrap(statement)), const_cast<GdaSet*>(Glib::unwrap(params)), ((GdaStatementSqlFlag)(flags)), &params_usedc, &(gerror)));
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   if(gerror)
@@ -271,6 +271,77 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<
 }
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage)
+#else
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, 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(), const_cast<GdaStatement*>(Glib::unwrap(stmt)), const_cast<GdaSet*>(Glib::unwrap(params)), ((GdaStatementModelUsage)(model_usage)), 0 /* col_types */, &(gerror)));
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  if(gerror)
+    ::Glib::Error::throw_exception(gerror);
+#else
+  if(gerror)
+    error = ::Glib::Error::throw_exception(gerror);
+#endif //GLIBMM_EXCEPTIONS_ENABLED
+
+  return retvalue;
+}
+
+
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& builder, StatementModelUsage model_usage)
+#else
+Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& builder, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
+#endif
+{
+  Glib::RefPtr<Gnome::Gda::Statement> stmt;
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  stmt = builder->get_statement(); //Allow any exceptions to be thrown up to the caller.
+#else
+  stmt = builder->get_statement(error);
+  if(error.get())
+    return Glib::RefPtr<DataModel>();
+#endif //GLIBMM_EXCEPTIONS_ENABLED
+
+  if(!stmt)
+     return Glib::RefPtr<DataModel>();
+
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  return statement_execute_select(stmt, model_usage);
+#else
+  return statement_execute_select(stmt, model_usage, error);
+#endif
+}
+
+
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& builder, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage)
+#else
+Glib::RefPtr<DataModel> Connection::statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& builder, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
+#endif
+{
+  Glib::RefPtr<Gnome::Gda::Statement> stmt;
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  stmt = builder->get_statement(); //Allow any exceptions to be thrown up to the caller.
+#else
+  stmt = builder->get_statement(error);
+  if(error.get())
+    return Glib::RefPtr<DataModel>();
+#endif //GLIBMM_EXCEPTIONS_ENABLED
+
+  if(!stmt)
+     return Glib::RefPtr<DataModel>();
+
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  return statement_execute_select(stmt, params, model_usage);
+#else
+  return statement_execute_select(stmt, params, model_usage, error);
+#endif
+}
+
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
 Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, StatementModelUsage model_usage)
 #else
 Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
@@ -305,6 +376,41 @@ Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring
   return retvalue;
 }
 
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage)
+#else
+Glib::RefPtr<DataModel> Connection::statement_execute_select(const Glib::ustring& sql, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error)
+#endif // GLIBMM_EXCEPTIONS_ENABLED
+{
+  Glib::RefPtr<const Statement> stmt;
+  Glib::RefPtr<SqlParser> parser = create_parser();
+  if(parser)
+  {
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+    stmt = parser->parse_string(sql);
+#else
+    stmt = parser->parse_string(sql, error);
+    if(error.get())
+      return Glib::RefPtr<DataModel>();
+#endif
+  }
+
+  if(!stmt)
+    return Glib::RefPtr<DataModel>();
+
+  GError* gerror = 0;
+  Glib::RefPtr<DataModel> retvalue = Glib::wrap(gda_connection_statement_execute_select_full(gobj(), const_cast<GdaStatement*>(Glib::unwrap(stmt)), const_cast<GdaSet*>(Glib::unwrap(params)), ((GdaStatementModelUsage)(model_usage)), 0 /* col_types */, &(gerror)));
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  if(gerror)
+    ::Glib::Error::throw_exception(gerror);
+#else
+  if(gerror)
+    error = ::Glib::Error::throw_exception(gerror);
+#endif //GLIBMM_EXCEPTIONS_ENABLED
+
+  return retvalue;
+}
+
 
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
 bool Connection::update_meta_store()
diff --git a/libgda/src/connection.hg b/libgda/src/connection.hg
index 79b12af..bc130f4 100644
--- a/libgda/src/connection.hg
+++ b/libgda/src/connection.hg
@@ -24,6 +24,7 @@
 #include <libgdamm/connectionevent.h>
 #include <libgdamm/datamodel.h>
 #include <libgdamm/statement.h>
+#include <libgdamm/sqlbuilder.h>
 #include <libgdamm/sqlparser.h>
 #include <libgdamm/serveroperation.h>
 #include <libgdamm/serverprovider.h> //For ServerProviderError, sometimes thrown by *execute*().
@@ -135,8 +136,13 @@ 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<const Statement>& stmt, const Glib::RefPtr<const 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)
+  _IGNORE(gda_connection_statement_execute_select) //We instead create a version that can take an optional usage parameter too.
 
+  #m4 _CONVERSION(`const Glib::ArrayHandle<GType>&', `GType*', `const_cast<GType*>(($3).data())')
+  _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)
+  
 //TODO: Documentation:
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
@@ -146,14 +152,36 @@ public:
   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<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)
+//TODO: Documentation:
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
+#else
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::RefPtr<const Statement>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
+  Glib::RefPtr<DataModel> statement_execute_select(const Glib::ustring& sql, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
+#endif
 
 
 //TODO: Documentation:
+//Note that we add the prefix _builder() because overloading on different RefPtr<> types seems to be ambiguous.
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
+#else
+  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
+#endif
+
+//TODO: Documentation:
+//Note that we add the prefix _builder() because overloading on different RefPtr<> types seems to be ambiguous.
+#ifdef GLIBMM_EXCEPTIONS_ENABLED
+  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage = STATEMENT_MODEL_RANDOM_ACCESS);
+#else
+  Glib::RefPtr<DataModel> statement_execute_select_builder(const Glib::RefPtr<const SqlBuilder>& stmt, const Glib::RefPtr<const Set>& params, StatementModelUsage model_usage, std::auto_ptr<Glib::Error>& error);
+#endif
+
+  
+  _WRAP_METHOD_DOCS_ONLY(gda_connection_statement_execute_non_select)
+//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<const Statement>& stmt, const Glib::RefPtr<const Set>& params, Glib::RefPtr<const Set>& last_insert_row);
@@ -165,7 +193,7 @@ public:
 #ifdef GLIBMM_EXCEPTIONS_ENABLED
   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<const Statement>& stmt,  const Glib::RefPtr<const 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:
@@ -311,9 +339,9 @@ public:
 
   //TODO: Add an overload without the params_used.
   #ifdef GLIBMM_EXCEPTIONS_ENABLED
-  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);
+  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) const;
   #else
-  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);
+  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) const;
   #endif //GLIBMM_EXCEPTIONS_ENABLED
     
   #m4 _CONVERSION(`GdaConnectionEvent*',`const Glib::RefPtr<ConnectionEvent>&',Glib::wrap($3, true))
diff --git a/libgda/src/sqlbuilder.ccg b/libgda/src/sqlbuilder.ccg
index 1a2c671..e942d74 100644
--- a/libgda/src/sqlbuilder.ccg
+++ b/libgda/src/sqlbuilder.ccg
@@ -80,6 +80,11 @@ guint SqlBuilder::add_function(const Glib::ustring& function_name, const Glib::A
   return gda_sql_builder_add_function_v(gobj(), 0, function_name.c_str(), args.data(), args.size());
 }
 
+guint SqlBuilder::add_function(const Glib::ustring& function_name, guint arg)
+{
+  return gda_sql_builder_add_function(gobj(), 0, function_name.c_str(), arg, 0, 0);
+}
+
 guint SqlBuilder::select_add_target(const Glib::ustring& table_name, const Glib::ustring& alias)
 {
   return gda_sql_builder_select_add_target(gobj(), table_name.c_str(), string_or_null(alias.c_str()));
diff --git a/libgda/src/sqlbuilder.hg b/libgda/src/sqlbuilder.hg
index 2c3dd83..4481a01 100644
--- a/libgda/src/sqlbuilder.hg
+++ b/libgda/src/sqlbuilder.hg
@@ -141,6 +141,15 @@ public:
     * @return The ID of the new target, or 0 if there was an error.
     */
   guint add_function(const Glib::ustring& function_name, const Glib::ArrayHandle<guint>& args);
+  
+    /** Builds a new expression which represents a function applied to an argument.
+    *
+    * @param function_name The name of the function to embed (e.g. MAX, MIN, ...)
+    * @param arg: The ids of the argument to the function
+    *
+    * @return The ID of the new target, or 0 if there was an error.
+    */
+  guint add_function(const Glib::ustring& function_name, guint arg);
 
   _WRAP_METHOD(void select_add_field(const Glib::ustring& field_name, const Glib::ustring& table_name, const Glib::ustring& alias = Glib::ustring()), gda_sql_builder_select_add_field)