static GdaRow *
create_new_row (GdaDataAccessWrapper *model)
{
gint i;
GdaRow *row;
row = gda_row_new (model->priv->nb_cols);
for (i = 0; i < model->priv->nb_cols; i++) {
GdaHolder *holder;
GValue *dest;
dest = gda_row_get_value (row, i);
if (model->priv->rows_mapping)
holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, model->priv->rows_mapping [i]);
else
holder = gda_set_get_nth_holder ((GdaSet *) model->priv->iter, i);
if (holder) {
const GValue *cvalue = gda_holder_get_value (holder);
if (cvalue) {
gda_value_reset_with_type (dest, G_VALUE_TYPE ((GValue *) cvalue));
g_value_copy (cvalue, dest);
}
else
gda_value_set_null (dest);
}
else
gda_row_invalidate_value (row, dest);
}
gint *ptr;
ptr = g_new (gint, 1);
*ptr = model->priv->iter_row;
g_hash_table_insert (model->priv->rows, ptr, row);
/*g_print ("%s(%d)\n", __FUNCTION__, model->priv->iter_row);*/
return row;
}
static GdaRow *
new_row_from_mysql_stmt (GdaMysqlRecordset *imodel, G_GNUC_UNUSED gint rownum, GError **error)
{
//g_print ("%s(): NCOLS=%d ROWNUM=%d\n", __func__, ((GdaDataSelect *) imodel)->prep_stmt->ncols, rownum);
int res;
MYSQL_BIND *mysql_bind_result;
g_return_val_if_fail (imodel->priv->mysql_stmt != NULL, NULL);
mysql_bind_result = ((GdaMysqlPStmt *) ((GdaDataSelect *) imodel)->prep_stmt)->mysql_bind_result;
g_assert (mysql_bind_result);
res = mysql_stmt_fetch (imodel->priv->mysql_stmt);
if (res == MYSQL_NO_DATA) {
/* should not happen */
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", "No more data, please report this bug to "
"http://bugzilla.gnome.org/ for the \"libgda\" product and the MySQL provider.");
}
else if (res == MYSQL_DATA_TRUNCATED) {
GString *string;
string = g_string_new ("Truncated data, please report this bug to "
"http://bugzilla.gnome.org/ for the \"libgda\" product and the MySQL provider.");
gint col;
for (col = 0; col < ((GdaDataSelect *) imodel)->prep_stmt->ncols; ++col) {
my_bool truncated;
mysql_bind_result[col].error = &truncated;
mysql_stmt_fetch_column (imodel->priv->mysql_stmt, &(mysql_bind_result[col]),
(unsigned int)col, 0);
if (truncated)
g_string_append_printf (string, "\n column %d is truncated\n", col);
mysql_bind_result[col].error = NULL;
}
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", string->str);
g_string_free (string, TRUE);
return NULL;
}
else if (res) {
_gda_mysql_make_error (imodel->priv->cnc, NULL, imodel->priv->mysql_stmt, error);
return NULL;
}
/* g_print ("%s: SQL=%s\n", __func__, ((GdaDataSelect *) imodel)->prep_stmt->sql); */
GdaRow *row = gda_row_new (((GdaDataSelect *) imodel)->prep_stmt->ncols);
gint col;
for (col = 0; col < ((GdaDataSelect *) imodel)->prep_stmt->ncols; ++col) {
gint i = col;
GValue *value = gda_row_get_value (row, i);
GType type = ((GdaDataSelect *) imodel)->prep_stmt->types[i];
/*g_print ("%s: #%d : TYPE=%d, GTYPE=%s\n", __func__, i, mysql_bind_result[i].buffer_type, g_type_name (type));*/
my_bool is_null = FALSE;
unsigned long length;
g_memmove (&is_null, mysql_bind_result[i].is_null, sizeof (my_bool));
if (is_null) {
gda_value_set_null (value);
continue;
}
else
gda_value_reset_with_type (value, type);
switch (mysql_bind_result[i].buffer_type) {
case MYSQL_TYPE_SHORT: {
short int bvalue = 0;
g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue));
g_value_set_int (value, bvalue);
break;
}
case MYSQL_TYPE_TINY: {
signed char bvalue = 0;
g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue));
g_value_set_int (value, bvalue);
break;
}
case MYSQL_TYPE_INT24:
case MYSQL_TYPE_LONG:
case MYSQL_TYPE_YEAR: {
int bvalue = 0;
g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue));
if (type == G_TYPE_INT)
g_value_set_int (value, bvalue);
else if (type == G_TYPE_LONG)
g_value_set_long (value, (long) bvalue);
else if (type == G_TYPE_BOOLEAN)
g_value_set_boolean (value, bvalue ? TRUE : FALSE);
else {
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Type %s not mapped for value %d"),
g_type_name (type), bvalue);
}
break;
}
case MYSQL_TYPE_LONGLONG: {
long long bvalue = 0;
g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue));
if (type == G_TYPE_BOOLEAN)
g_value_set_boolean (value, bvalue ? TRUE : FALSE);
else if (type == G_TYPE_INT)
g_value_set_int (value, bvalue);
else if (type == G_TYPE_LONG)
g_value_set_long (value, bvalue);
else {
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Type %s not mapped for value %lld"),
g_type_name (type), bvalue);
}
break;
}
case MYSQL_TYPE_NULL:
gda_value_set_null (value);
break;
case MYSQL_TYPE_TIME:
case MYSQL_TYPE_DATE:
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP: {
MYSQL_TIME bvalue = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue));
if (type == GDA_TYPE_TIME) {
GdaTime time = {
.hour = bvalue.hour,
.minute = bvalue.minute,
.second = bvalue.second,
.fraction = bvalue.second_part,
.timezone = 0 /* GMT */
};
gda_value_set_time (value, &time);
}
else if (type == G_TYPE_DATE) {
GDate *date = g_date_new_dmy
((bvalue.day != 0) ? bvalue.day : 1,
(bvalue.month != 0) ? bvalue.month : 1,
(bvalue.year != 0) ? bvalue.year : 1970);
g_value_take_boxed (value, date);
}
else if (type == GDA_TYPE_TIMESTAMP) {
GdaTimestamp timestamp = {
.year = bvalue.year,
.month = bvalue.month,
.day = bvalue.day,
.hour = bvalue.hour,
.minute = bvalue.minute,
.second = bvalue.second,
.fraction = bvalue.second_part,
.timezone = 0 /* GMT */
};
gda_value_set_timestamp (value, ×tamp);
}
else {
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Type %s not mapped for value %d/%d/%d %d:%d:%d.%lu"),
g_type_name (type), bvalue.year, bvalue.month,
bvalue.day, bvalue.hour, bvalue.minute,
bvalue.second, bvalue.second_part);
}
break;
}
case MYSQL_TYPE_FLOAT: {
float bvalue = 0.;
g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue));
if (type == G_TYPE_FLOAT)
g_value_set_float (value, (float) bvalue);
else {
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Type %s not mapped for value %f"),
g_type_name (type), bvalue);
}
break;
}
case MYSQL_TYPE_DOUBLE: {
double bvalue = 0.0;
g_memmove (&bvalue, mysql_bind_result[i].buffer, sizeof (bvalue));
if (type == G_TYPE_DOUBLE)
g_value_set_double (value, bvalue);
else {
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Type %s not mapped for value %f"),
g_type_name (type), bvalue);
}
break;
}
case MYSQL_TYPE_STRING:
case MYSQL_TYPE_VAR_STRING:
case MYSQL_TYPE_BLOB:
case MYSQL_TYPE_TINY_BLOB:
case MYSQL_TYPE_MEDIUM_BLOB:
case MYSQL_TYPE_LONG_BLOB:
case MYSQL_TYPE_NEWDECIMAL:
case MYSQL_TYPE_DECIMAL:
case MYSQL_TYPE_BIT: {
char *bvalue = NULL;
g_memmove (&length, mysql_bind_result[i].length, sizeof (unsigned long));
if (length > 0) {
bvalue = g_malloc (length + 1);
memcpy (bvalue, mysql_bind_result[i].buffer, length);
bvalue [length] = 0;
}
if (type == G_TYPE_STRING)
g_value_set_string (value, bvalue);
else if (type == GDA_TYPE_BINARY) {
GdaBinary binary = {
.data = (guchar*) bvalue,
.binary_length = length
};
gda_value_set_binary (value, &binary);
}
else if (type == GDA_TYPE_BLOB) {
/* we don't use GdaMysqlBlobOp because it looks like the MySQL
* API does not support BLOBs accessed in a random way,
* so we return the whole BLOB at once */
GdaBlob blob = { {(guchar*) bvalue, length}, NULL };
gda_value_set_blob (value, &blob);
}
else if (type == GDA_TYPE_NUMERIC) {
if (length > 0) {
GdaNumeric *numeric;
numeric = gda_numeric_new ();
gda_numeric_set_from_string (numeric, bvalue);
gda_numeric_set_precision (numeric, 6);
gda_numeric_set_width (numeric, length);
gda_value_set_numeric (value, numeric);
gda_numeric_free (numeric);
}
}
else if (type == G_TYPE_DOUBLE) {
if (length > 0)
g_value_set_double (value, g_ascii_strtod (bvalue, NULL));
else {
/* error: wrong column type */
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid column bind data type. %d\n"),
mysql_bind_result[i].buffer_type);
break;
}
}
else if (type == G_TYPE_INT) {
if (length > 0)
g_value_set_int (value, atoi (bvalue));
else {
/* error: wrong column type */
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid column bind data type. %d\n"),
mysql_bind_result[i].buffer_type);
break;
}
}
else if (type == G_TYPE_BOOLEAN) {
if (length > 0)
g_value_set_boolean (value, atoi (bvalue));
else {
/* error: wrong column type */
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid column bind data type. %d\n"),
mysql_bind_result[i].buffer_type);
break;
}
}
else {
gda_row_invalidate_value (row, value);
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Type %s not mapped for value %s"),
g_type_name (type), bvalue);
}
g_free (bvalue);
break;
}
GdaDataModel *
gda_mysql_recordset_new_direct (GdaConnection *cnc, GdaDataModelAccessFlags flags,
GType *col_types)
{
GdaMysqlRecordset *model;
MysqlConnectionData *cdata;
gint i;
GdaDataModelAccessFlags rflags;
GSList *columns = NULL;
g_return_val_if_fail (GDA_IS_CONNECTION (cnc), NULL);
cdata = (MysqlConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);
if (!cdata)
return NULL;
/* determine access mode: RANDOM or CURSOR FORWARD are the only supported */
if (flags & GDA_DATA_MODEL_ACCESS_RANDOM)
rflags = GDA_DATA_MODEL_ACCESS_RANDOM;
else
rflags = GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD;
/* create data model */
model = g_object_new (GDA_TYPE_MYSQL_RECORDSET,
"connection", cnc,
"model-usage", rflags,
NULL);
model->priv->cnc = cnc;
g_object_ref (G_OBJECT(cnc));
/* columns & types */
model->priv->ncols = mysql_field_count (cdata->mysql);
model->priv->types = g_new0 (GType, model->priv->ncols);
/* create columns */
for (i = 0; i < model->priv->ncols; i++)
columns = g_slist_prepend (columns, gda_column_new ());
columns = g_slist_reverse (columns);
if (col_types) {
for (i = 0; ; i++) {
if (col_types [i] > 0) {
if (col_types [i] == G_TYPE_NONE)
break;
if (i >= model->priv->ncols) {
g_warning (_("Column %d out of range (0-%d), ignoring its specified type"), i,
model->priv->ncols - 1);
break;
}
else
model->priv->types [i] = col_types [i];
}
}
}
/* fill bind result */
MYSQL_RES *mysql_res = mysql_store_result (cdata->mysql);
MYSQL_FIELD *mysql_fields = mysql_fetch_fields (mysql_res);
GSList *list;
((GdaDataSelect *) model)->advertized_nrows = mysql_affected_rows (cdata->mysql);
for (i=0, list = columns;
i < model->priv->ncols;
i++, list = list->next) {
GdaColumn *column = GDA_COLUMN (list->data);
/* use C API to set columns' information using gda_column_set_*() */
MYSQL_FIELD *field = &mysql_fields[i];
GType gtype = model->priv->types [i];
if (gtype == GDA_TYPE_NULL) {
gtype = _gda_mysql_type_to_gda (cdata, field->type, field->charsetnr);
model->priv->types [i] = gtype;
}
gda_column_set_g_type (column, gtype);
gda_column_set_name (column, field->name);
gda_column_set_description (column, field->name);
}
gda_data_select_set_columns (GDA_DATA_SELECT (model), columns);
/* load ALL data */
MYSQL_ROW mysql_row;
gint rownum;
GdaServerProvider *prov;
prov = gda_connection_get_provider (cnc);
for (mysql_row = mysql_fetch_row (mysql_res), rownum = 0;
mysql_row;
mysql_row = mysql_fetch_row (mysql_res), rownum++) {
GdaRow *row = gda_row_new (model->priv->ncols);
gint col;
for (col = 0; col < model->priv->ncols; col++) {
gint i = col;
GValue *value = gda_row_get_value (row, i);
GType type = model->priv->types[i];
char *data = mysql_row[i];
if (!data || (type == GDA_TYPE_NULL))
continue;
gda_value_reset_with_type (value, type);
if (type == G_TYPE_STRING)
g_value_set_string (value, data);
else {
GdaDataHandler *dh;
gboolean valueset = FALSE;
dh = gda_server_provider_get_data_handler_g_type (prov, cnc, type);
if (dh) {
GValue *tmpvalue;
tmpvalue = gda_data_handler_get_value_from_str (dh, data, type);
if (tmpvalue) {
*value = *tmpvalue;
g_free (tmpvalue);
valueset = TRUE;
}
}
if (!valueset)
gda_row_invalidate_value (row, value);
}
}
gda_data_select_take_row ((GdaDataSelect*) model, row, rownum);
}
mysql_free_result (mysql_res);
return GDA_DATA_MODEL (model);
}