/**
* _gda_web_set_connection_error_from_xmldoc
*
* Handles errors reported by @doc, and ser @error if not %NULL
*
* Returns: a #GdaConnectionEvent, which must not be modified or freed
*/
GdaConnectionEvent *
_gda_web_set_connection_error_from_xmldoc (GdaConnection *cnc, xmlDocPtr doc, GError **error)
{
xmlNodePtr node, root;
GdaConnectionEvent *ev = NULL;
g_return_val_if_fail (doc, NULL);
root = xmlDocGetRootElement (doc);
for (node = root->children; node; node = node->next) {
if (!strcmp ((gchar*) node->name, "status")) {
xmlChar *prop;
prop = xmlGetProp (node, BAD_CAST "error");
if (prop) {
ev = gda_connection_add_event_string (cnc, (gchar*) prop);
xmlFree (prop);
}
else
ev = gda_connection_add_event_string (cnc, _("Non detailed error"));
break;
}
}
if (ev && error) {
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_STATEMENT_EXEC_ERROR, "%s",
gda_connection_event_get_description (ev));
}
return ev;
}
static GdaRow *
fetch_next_oracle_row (GdaOracleRecordset *model, G_GNUC_UNUSED gboolean do_store, GError **error)
{
int result;
GdaRow *prow = NULL;
GdaOraclePStmt *ps = GDA_ORACLE_PSTMT (((GdaDataSelect*)model)->prep_stmt);
OracleConnectionData *cdata;
GdaConnection *cnc;
cnc = gda_data_select_get_connection ((GdaDataSelect*) model);
cdata = (OracleConnectionData*) gda_connection_internal_get_provider_data_error (cnc, error);
if (!cdata)
return NULL;
/* fetch row */
if (cdata->major_version > 9)
result = OCIStmtFetch2 (ps->hstmt,
cdata->herr,
(ub4) 1,
(ub2) OCI_FETCH_NEXT,
(sb4) 1,
(ub4) OCI_DEFAULT);
else
result = OCIStmtFetch (ps->hstmt,
cdata->herr,
(ub4) 1,
(ub2) OCI_FETCH_NEXT,
(ub4) OCI_DEFAULT);
if (result == OCI_NO_DATA) {
GDA_DATA_SELECT (model)->advertized_nrows = model->priv->next_row_num;
return NULL;
}
else {
GdaConnectionEvent *event;
if ((event = gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not fetch next row")))) {
/* set @error */
g_set_error (error, GDA_SERVER_PROVIDER_ERROR, GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", gda_connection_event_get_description (event));
return NULL;
}
}
prow = new_row ((GdaDataSelect*) model, cnc, ps);
gda_data_select_take_row ((GdaDataSelect*) model, prow, model->priv->next_row_num);
model->priv->next_row_num ++;
return prow;
}
/*
* _gda_oracle_handle_error
* This function is used for checking the result of an OCI
* call. The result itself is the return value, and we
* need the GdaConnection and OracleConnectionData to do
* our thing. The type is OCI_HTYPE_ENV or OCI_HTYPE_ERROR
* as described for OCIErrorGet.
*
* The return value is true if there is no error, or false otherwise
*
* If the return value is OCI_SUCCESS or OCI_SUCCESS_WITH_INFO,
* we return TRUE. Otherwise, if it is OCI_ERROR, try to get the
* Oracle error message using _gda_oracle_make_error. Otherwise,
* make an error using the given message.
*/
GdaConnectionEvent *
_gda_oracle_handle_error (gint result, GdaConnection *cnc,
OracleConnectionData *cdata,
ub4 type, const gchar *msg,
const gchar *file, gint line)
{
GdaConnectionEvent *error = NULL;
g_return_val_if_fail (GDA_IS_CONNECTION (cnc), FALSE);
switch (result) {
case OCI_SUCCESS:
case OCI_SUCCESS_WITH_INFO:
return NULL;
case OCI_ERROR:
switch(type) {
case OCI_HTYPE_ERROR:
error = _gda_oracle_make_error (cnc, cdata->herr, type, file, line);
gda_connection_add_event (cnc, error);
break;
case OCI_HTYPE_ENV:
error = _gda_oracle_make_error (cnc, cdata->henv, type, file, line);
if (error)
gda_connection_add_event (cnc, error);
break;
default:
if (error)
error = gda_connection_add_event_string (cnc, msg);
gda_connection_add_event (cnc, error);
break;
}
break;
case OCI_NO_DATA:
g_warning ("Internal implementation error: OCI_NO_DATA not handled!\n");
break;
case OCI_INVALID_HANDLE:
g_warning ("Internal error: Invalid handle!");
default:
error = gda_connection_add_event_string (cnc, msg);
}
#ifdef GDA_DEBUG
if (error)
g_print ("HANDLED error: %s\n", gda_connection_event_get_description (error));
#endif
return error;
}
void
gda_transaction_status_dump (GdaTransactionStatus *tstatus, guint offset)
{
gchar *str;
GList *evlist;
gchar *levels[] = {"GDA_TRANSACTION_ISOLATION_UNKNOWN",
"GDA_TRANSACTION_ISOLATION_READ_COMMITTED",
"GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED",
"GDA_TRANSACTION_ISOLATION_REPEATABLE_READ",
"GDA_TRANSACTION_ISOLATION_SERIALIZABLE"};
#define level_str(lev) ((lev < 4) ? levels[lev] : "UNKNOWN ISOLATION LEVEL")
g_return_if_fail (GDA_IS_TRANSACTION_STATUS (tstatus));
str = g_new (gchar, offset+1);
memset (str, ' ', offset);
str [offset] = 0;
g_print ("%sGdaTransactionStatus: %s (%s, %p)\n", str, tstatus->name ? tstatus->name : "(NONAME)",
level_str (tstatus->isolation_level), tstatus);
for (evlist = tstatus->events; evlist; evlist = evlist->next) {
GdaTransactionStatusEvent *ev = (GdaTransactionStatusEvent *) (evlist->data);
switch (ev->type) {
case GDA_TRANSACTION_STATUS_EVENT_SAVEPOINT:
g_print ("%s *SAVE POINT %s (%p)\n", str, ev->pl.svp_name, ev);
break;
case GDA_TRANSACTION_STATUS_EVENT_SQL:
g_print ("%s *SQL %s (%p): %s\n", str, ev->pl.sql, ev,
ev->conn_event ? gda_connection_event_get_description (ev->conn_event) : "_no event_");
break;
case GDA_TRANSACTION_STATUS_EVENT_SUB_TRANSACTION:
g_print ("%s *SUB TRANSACTION (%p)\n", str, ev);
gda_transaction_status_dump (ev->pl.sub_trans, offset + 5);
break;
default:
g_assert_not_reached ();
}
}
g_free (str);
}
static const gchar *
sql_get_last_error (GdaConnection *connection)
{
GList *list;
GdaConnectionEvent *error;
const gchar *error_txt;
g_return_val_if_fail (GDA_IS_CONNECTION (connection),
_("Can't connect to database server"));
list = (GList *) gda_connection_get_events (connection);
if (list == NULL) {
return _("No errors reported.");
}
error = (GdaConnectionEvent *) g_list_last (list)->data;
/* FIXME: Poor user, she won't get localized messages */
error_txt = gda_connection_event_get_description (error);
return error_txt;
}
