/*
* executed in the sub thread (the one which can manipulate @sub_model)
*/
GdaDataModel *
_gda_thread_recordset_new (GdaConnection *cnc, GdaThreadWrapper *wrapper, GdaDataModel *sub_model)
{
GdaThreadRecordset *model;
gint ncols, i, nblobs;
gint *blobs_conv = NULL;
model = GDA_THREAD_RECORDSET (g_object_new (GDA_TYPE_THREAD_RECORDSET,
"connection", cnc, NULL));
_gda_data_select_share_private_data (GDA_DATA_SELECT (sub_model),
GDA_DATA_SELECT (model));
model->priv->wrapper = g_object_ref (wrapper);
model->priv->sub_model = g_object_ref (sub_model);
ncols = gda_data_model_get_n_columns (sub_model);
nblobs = 0;
for (i = 0; i < ncols; i++) {
GdaColumn *col;
col = gda_data_model_describe_column (sub_model, i);
if (gda_column_get_g_type (col) == GDA_TYPE_BLOB) {
if (!blobs_conv)
blobs_conv = g_new0 (gint, ncols);
blobs_conv [nblobs] = i;
nblobs++;
}
}
model->priv->blobs_conv = blobs_conv;
model->priv->nblobs = nblobs;
COPY_PUBLIC_DATA (sub_model, model);
return GDA_DATA_MODEL (model);
}
static void
compute_columns (GdaDataAccessWrapper *model)
{
if (model->priv->rows_mapping) {
/* use model->priv->rows_mapping to create columns, and correct it if
* needed to remove out of range columns */
gint *nmapping;
gint i, j, nb_cols;
g_assert (!model->priv->columns);
nmapping = g_new (gint, model->priv->nb_cols);
nb_cols = gda_data_model_get_n_columns (model->priv->model);
for (i = 0, j = 0; i < model->priv->nb_cols; i++) {
gint nb = model->priv->rows_mapping [i];
if (nb >= nb_cols)
continue;
GdaColumn *column;
column = gda_data_model_describe_column (model->priv->model, nb);
if (!column)
continue;
model->priv->columns = g_slist_append (model->priv->columns,
gda_column_copy (column));
nmapping [j] = nb;
j++;
}
model->priv->nb_cols = j;
g_free (model->priv->rows_mapping);
model->priv->rows_mapping = nmapping;
}
else
model->priv->nb_cols = gda_data_model_get_n_columns (model->priv->model);
}
static void
text_tag_table_foreach_cb (GtkTextTag *tag, FilterData *fdata)
{
const GValue *cvalue;
const gchar *label;
gint row;
if (! fdata->cloud->priv->model)
return;
if (fdata->cloud->priv->label_column < 0)
return;
/* check for the data model's column type */
GdaColumn *column;
column = gda_data_model_describe_column (fdata->cloud->priv->model,
fdata->cloud->priv->label_column);
if (!column || (gda_column_get_g_type (column) != G_TYPE_STRING)) {
g_warning (_("Wrong column type for label: expecting a string and got a %s"),
gda_g_type_to_string (gda_column_get_g_type (column)));
return;
}
row = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (tag), "row")) - 1;
if (row < 0)
return;
cvalue = gda_data_model_get_value_at (fdata->cloud->priv->model,
fdata->cloud->priv->label_column, row, NULL);
if (!cvalue)
return;
label = g_value_get_string (cvalue);
if (!(fdata->find) || !*(fdata->find)) {
g_object_set (tag, "foreground", "#6161F2", NULL);
}
else {
gchar *ptr, *lcname, *lcfind;
lcname = prepare_cmp_string (label);
lcfind = prepare_cmp_string (fdata->find);
ptr = strstr (lcname, lcfind);
if (!ptr) {
/* string not present in name */
g_object_set (tag, "foreground", "#DBDBDB", NULL);
}
else if ((ptr == lcname) ||
((*label == '"') && (ptr == lcname+1))) {
/* string present as start of name */
g_object_set (tag, "foreground", "#6161F2", NULL);
}
else {
/* string present in name but not at the start */
g_object_set (tag, "foreground", "#A0A0A0", NULL);
}
g_free (lcname);
g_free (lcfind);
}
}
/**
* gda_data_model_array_copy_model:
* @src: a #GdaDataModel to copy data from
* @error: a place to store errors, or %NULL
*
* Makes a copy of @src into a new #GdaDataModelArray object
*
* Returns: (transfer full) (allow-none): a new data model, or %NULL if an error occurred
*/
GdaDataModelArray *
gda_data_model_array_copy_model (GdaDataModel *src, GError **error)
{
GdaDataModel *model;
gint nbfields, i;
g_return_val_if_fail (GDA_IS_DATA_MODEL (src), NULL);
nbfields = gda_data_model_get_n_columns (src);
model = gda_data_model_array_new (nbfields);
if (g_object_get_data (G_OBJECT (src), "name"))
g_object_set_data_full (G_OBJECT (model), "name", g_strdup (g_object_get_data (G_OBJECT (src), "name")), g_free);
if (g_object_get_data (G_OBJECT (src), "descr"))
g_object_set_data_full (G_OBJECT (model), "descr", g_strdup (g_object_get_data (G_OBJECT (src), "descr")), g_free);
for (i = 0; i < nbfields; i++) {
GdaColumn *copycol, *srccol;
gchar *colid;
srccol = gda_data_model_describe_column (src, i);
copycol = gda_data_model_describe_column (model, i);
g_object_get (G_OBJECT (srccol), "id", &colid, NULL);
g_object_set (G_OBJECT (copycol), "id", colid, NULL);
g_free (colid);
gda_column_set_description (copycol, gda_column_get_description (srccol));
gda_column_set_name (copycol, gda_column_get_name (srccol));
gda_column_set_dbms_type (copycol, gda_column_get_dbms_type (srccol));
gda_column_set_g_type (copycol, gda_column_get_g_type (srccol));
gda_column_set_position (copycol, gda_column_get_position (srccol));
gda_column_set_allow_null (copycol, gda_column_get_allow_null (srccol));
}
if (! gda_data_model_import_from_model (model, src, FALSE, NULL, error)) {
g_object_unref (model);
model = NULL;
}
/*else
gda_data_model_dump (model, stdout);*/
return (GdaDataModelArray*) model;
}
static GdaColumn *
gda_data_meta_wrapper_describe_column (GdaDataModel *model, gint col)
{
GdaDataMetaWrapper *imodel;
g_return_val_if_fail (GDA_IS_DATA_META_WRAPPER (model), NULL);
imodel = GDA_DATA_META_WRAPPER (model);
g_return_val_if_fail (imodel->priv, NULL);
if (imodel->priv->model)
return gda_data_model_describe_column (imodel->priv->model, col);
else
return NULL;
}
/**
* gda_data_model_array_new_with_g_types_v:
* @cols: number of columns for rows in this data model.
* @types: (array): array of types of the columns of the model to create as #GType, as many as indicated by @cols
*
* Creates a new #GdaDataModel object with the column types as
* specified.
*
* Returns: (transfer full): a pointer to the newly created #GdaDataModel.
*
* Since: 4.2.6
*
* Rename to: gda_data_model_array_new_with_g_types
*/
GdaDataModel *
gda_data_model_array_new_with_g_types_v (gint cols, GType *types)
{
GdaDataModel *model;
gint i;
model = gda_data_model_array_new (cols);
i = 0;
while (i < cols) {
GType type = types [i];
gda_column_set_g_type (gda_data_model_describe_column (model, i), type);
i++;
}
return model;
}
static GdaColumn *
gda_data_access_wrapper_describe_column (GdaDataModel *model, gint col)
{
GdaDataAccessWrapper *imodel;
g_return_val_if_fail (GDA_IS_DATA_ACCESS_WRAPPER (model), NULL);
imodel = (GdaDataAccessWrapper*) model;
g_return_val_if_fail (imodel->priv, NULL);
if (imodel->priv->model) {
if (imodel->priv->columns)
return g_slist_nth_data (imodel->priv->columns, col);
else
return gda_data_model_describe_column (imodel->priv->model, col);
}
else
return NULL;
}
/**
* gda_data_model_array_new_with_g_types: (skip)
* @cols: number of columns for rows in this data model.
* @...: types of the columns of the model to create as #GType, as many as indicated by @cols
*
* Creates a new #GdaDataModel object with the column types as
* specified.
*
* Returns: (transfer full): a pointer to the newly created #GdaDataModel.
*/
GdaDataModel *
gda_data_model_array_new_with_g_types (gint cols, ...)
{
GdaDataModel *model;
va_list args;
gint i;
model = gda_data_model_array_new (cols);
va_start (args, cols);
i = 0;
while (i < cols) {
gint argtype;
argtype = va_arg (args, GType);
g_assert (argtype >= 0);
gda_column_set_g_type (gda_data_model_describe_column (model, i),
(GType) argtype);
i++;
}
va_end (args);
return model;
}
static void
update_display (GdauiCloud *cloud)
{
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
/* clean all */
tbuffer = cloud->priv->tbuffer;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
if (cloud->priv->selected_tags) {
g_slist_foreach (cloud->priv->selected_tags, (GFunc) g_object_unref, NULL);
g_slist_free (cloud->priv->selected_tags);
cloud->priv->selected_tags = NULL;
sync_iter_with_selection (cloud);
g_signal_emit_by_name (cloud, "selection-changed");
}
if (!cloud->priv->model)
return;
if (cloud->priv->label_column < 0)
return;
/* check for the data model's column type */
GdaColumn *column;
column = gda_data_model_describe_column (cloud->priv->model, cloud->priv->label_column);
if (!column || (gda_column_get_g_type (column) != G_TYPE_STRING)) {
g_warning (_("Wrong column type for label: expecting a string and got a %s"),
gda_g_type_to_string (gda_column_get_g_type (column)));
return;
}
gint nrows, i;
nrows = gda_data_model_get_n_rows (cloud->priv->model);
/* compute scale range */
gdouble min_weight = G_MAXDOUBLE, max_weight = G_MINDOUBLE, wrange;
if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
gdouble weight = 1.;
if (cloud->priv->weight_func) {
weight = cloud->priv->weight_func (cloud->priv->model, i,
cloud->priv->weight_func_data);
min_weight = MIN (min_weight, weight);
max_weight = MAX (max_weight, weight);
}
else {
cvalue = gda_data_model_get_value_at (cloud->priv->model,
cloud->priv->weight_column, i, NULL);
if (cvalue) {
weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
min_weight = MIN (min_weight, weight);
max_weight = MAX (max_weight, weight);
}
}
}
}
if (max_weight > min_weight)
wrange = (cloud->priv->max_scale - cloud->priv->min_scale) / (max_weight - min_weight);
else
wrange = 0.;
gtk_text_buffer_get_start_iter (tbuffer, &start);
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
gdouble weight = 1.;
const gchar *ptr;
GString *string;
cvalue = gda_data_model_get_value_at (cloud->priv->model, cloud->priv->label_column, i, NULL);
if (!cvalue) {
TO_IMPLEMENT;
continue;
}
if (!g_value_get_string (cvalue))
continue;
/* convert spaces to non breaking spaces (0xC2 0xA0 as UTF8) */
string = g_string_new ("");
for (ptr = g_value_get_string (cvalue); *ptr; ptr++) {
if (*ptr == ' ') {
g_string_append_c (string, 0xC2);
g_string_append_c (string, 0xA0);
}
else
g_string_append_c (string, *ptr);
}
if ((cloud->priv->weight_column >= 0) || cloud->priv->weight_func) {
if (cloud->priv->weight_func) {
weight = cloud->priv->weight_func (cloud->priv->model, i,
cloud->priv->weight_func_data);
weight = cloud->priv->min_scale + wrange * (weight - min_weight);
}
else {
cvalue = gda_data_model_get_value_at (cloud->priv->model,
cloud->priv->weight_column, i, NULL);
if (cvalue) {
weight = g_ascii_strtod (gda_value_stringify (cvalue), NULL);
weight = cloud->priv->min_scale + wrange * (weight - min_weight);
}
}
}
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (cloud->priv->tbuffer, NULL,
"foreground", "#6161F2",
"scale", weight,
NULL);
g_object_set_data ((GObject*) tag, "row", GINT_TO_POINTER (i) + 1);
gtk_text_buffer_insert_with_tags (cloud->priv->tbuffer, &start, string->str, -1,
tag, NULL);
g_string_free (string, TRUE);
gtk_text_buffer_insert (cloud->priv->tbuffer, &start, " ", -1);
}
}
static GdaRow *
fetch_next_sqlite_row (GdaSqliteRecordset *model, gboolean do_store, GError **error)
{
int rc;
SqliteConnectionData *cdata;
GdaSqlitePStmt *ps;
GdaRow *prow = NULL;
GdaConnection *cnc;
glong length;
cnc = gda_data_select_get_connection ((GdaDataSelect*) model);
cdata = (SqliteConnectionData*) gda_connection_internal_get_provider_data_error (cnc, error);
if (!cdata)
return NULL;
ps = GDA_SQLITE_PSTMT (GDA_DATA_SELECT (model)->prep_stmt);
virt_cnc_set_working_obj (gda_data_select_get_connection ((GdaDataSelect*) model), model);
if (model->priv->empty_forced)
rc = SQLITE_DONE;
else
rc = SQLITE3_CALL (sqlite3_step) (ps->sqlite_stmt);
switch (rc) {
case SQLITE_ROW: {
gint col, real_col;
prow = gda_row_new (_GDA_PSTMT (ps)->ncols);
for (col = 0; col < _GDA_PSTMT (ps)->ncols; col++) {
GValue *value;
GType type = _GDA_PSTMT (ps)->types [col];
real_col = col + ps->nb_rowid_columns;
if (type == GDA_TYPE_NULL) {
type = fuzzy_get_gtype (cdata, ps, col);
if (type == GDA_TYPE_BLOB) {
/* extra check: make sure we have a rowid for this blob, or fallback to binary */
if (ps->rowid_hash) {
gint oidcol = 0;
const char *ctable;
ctable = SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
if (oidcol == 0) {
ctable = SQLITE3_CALL (sqlite3_column_table_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
}
if (oidcol == 0)
type = GDA_TYPE_BINARY;
}
else
type = GDA_TYPE_BINARY;
}
if (type != GDA_TYPE_NULL) {
GdaColumn *column;
_GDA_PSTMT (ps)->types [col] = type;
column = gda_data_model_describe_column (GDA_DATA_MODEL (model), col);
gda_column_set_g_type (column, type);
column = (GdaColumn *) g_slist_nth_data (_GDA_PSTMT (ps)->tmpl_columns, col);
gda_column_set_g_type (column, type);
}
}
/* fill GValue */
value = gda_row_get_value (prow, col);
GError *may_error;
may_error = (GError*) SQLITE3_CALL (sqlite3_column_blob) (ps->sqlite_stmt, real_col);
if (may_error && g_hash_table_lookup (error_blobs_hash, may_error)) {
/*g_print ("Row invalidated: [%s]\n", may_error->message);*/
gda_row_invalidate_value_e (prow, value, may_error);
g_hash_table_remove (error_blobs_hash, may_error);
}
else if (SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col) == NULL) {
/* we have a NULL value */
gda_value_set_null (value);
}
else {
gda_value_reset_with_type (value, type);
if (type == GDA_TYPE_NULL)
;
else if (type == G_TYPE_INT) {
gint64 i;
i = SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXINT) || (i < G_MININT)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_int (value, (gint) i);
}
else if (type == G_TYPE_UINT) {
guint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if (i > G_MAXUINT) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_uint (value, (gint) i);
}
else if (type == G_TYPE_INT64)
g_value_set_int64 (value, SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col));
else if (type == G_TYPE_UINT64)
g_value_set_uint64 (value, (guint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt,
real_col));
else if (type == G_TYPE_DOUBLE)
g_value_set_double (value, SQLITE3_CALL (sqlite3_column_double) (ps->sqlite_stmt,
real_col));
else if (type == G_TYPE_STRING)
g_value_set_string (value, (gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col));
else if (type == GDA_TYPE_BINARY) {
GdaBinary *bin;
bin = gda_binary_new ();
length = SQLITE3_CALL (sqlite3_column_bytes) (ps->sqlite_stmt, real_col);
if (length > 0) {
gda_binary_set_data (bin, SQLITE3_CALL (sqlite3_column_blob) (ps->sqlite_stmt, /* Flawfinder: ignore */
real_col), length);
}
gda_value_take_binary (value, bin);
}
else if (type == GDA_TYPE_BLOB) {
GdaBlobOp *bop = NULL;
gint oidcol = 0;
if (ps->rowid_hash) {
const char *ctable;
ctable = SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
if (oidcol == 0) {
ctable = SQLITE3_CALL (sqlite3_column_table_name) (ps->sqlite_stmt, real_col);
if (ctable)
oidcol = GPOINTER_TO_INT (g_hash_table_lookup (ps->rowid_hash,
ctable));
}
}
if (oidcol != 0) {
gint64 rowid;
rowid = SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, oidcol - 1); /* remove 1
because it was added in the first place */
bop = _gda_sqlite_blob_op_new (cnc,
SQLITE3_CALL (sqlite3_column_database_name) (ps->sqlite_stmt,
real_col),
SQLITE3_CALL (sqlite3_column_table_name) (ps->sqlite_stmt,
real_col),
SQLITE3_CALL (sqlite3_column_origin_name) (ps->sqlite_stmt,
real_col),
rowid);
}
if (!bop) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Unable to open BLOB"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else {
GdaBlob *blob;
blob = gda_blob_new ();
gda_blob_set_op (blob, bop);
g_object_unref (bop);
gda_value_take_blob (value, blob);
}
}
else if (type == G_TYPE_BOOLEAN)
g_value_set_boolean (value, SQLITE3_CALL (sqlite3_column_int) (ps->sqlite_stmt, real_col) == 0 ? FALSE : TRUE);
else if (type == G_TYPE_DATE) {
GDate date;
if (!gda_parse_iso8601_date (&date,
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col))) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid date '%s' (date format should be YYYY-MM-DD)"),
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_boxed (value, &date);
}
else if (type == GDA_TYPE_TIME) {
GdaTime timegda;
if (!gda_parse_iso8601_time (&timegda,
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col))) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid time '%s' (time format should be HH:MM:SS[.ms])"),
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col));
gda_row_invalidate_value_e (prow, value, lerror);
}
else {
if (timegda.timezone == GDA_TIMEZONE_INVALID)
timegda.timezone = 0; /* set to GMT */
gda_value_set_time (value, &timegda);
}
}
else if (type == GDA_TYPE_TIMESTAMP) {
GdaTimestamp timestamp;
if (!gda_parse_iso8601_timestamp (×tamp,
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt,
real_col))) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
_("Invalid timestamp '%s' (format should be YYYY-MM-DD HH:MM:SS[.ms])"),
(gchar *) SQLITE3_CALL (sqlite3_column_text) (ps->sqlite_stmt, real_col));
gda_row_invalidate_value_e (prow, value, lerror);
}
else {
if (timestamp.timezone == GDA_TIMEZONE_INVALID)
timestamp.timezone = 0; /* set to GMT */
gda_value_set_timestamp (value, ×tamp);
}
}
else if (type == G_TYPE_CHAR) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXINT8) || (i < G_MININT8)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_schar (value, (gchar) i);
}
else if (type == G_TYPE_UCHAR) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXUINT8) || (i < 0)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
g_value_set_uchar (value, (guchar) i);
}
else if (type == GDA_TYPE_SHORT) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXSHORT) || (i < G_MINSHORT)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
gda_value_set_short (value, (guchar) i);
}
else if (type == GDA_TYPE_USHORT) {
gint64 i;
i = (gint64) SQLITE3_CALL (sqlite3_column_int64) (ps->sqlite_stmt, real_col);
if ((i > G_MAXUSHORT) || (i < 0)) {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"%s", _("Integer value is too big"));
gda_row_invalidate_value_e (prow, value, lerror);
}
else
gda_value_set_ushort (value, (guchar) i);
}
else {
GError *lerror = NULL;
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_DATA_ERROR,
"Unhandled type '%s' in SQLite recordset",
gda_g_type_to_string (_GDA_PSTMT (ps)->types [col]));
gda_row_invalidate_value_e (prow, value, lerror);
}
}
}
if (do_store) {
/* insert row */
gda_data_select_take_row (GDA_DATA_SELECT (model), prow, model->priv->next_row_num);
}
model->priv->next_row_num ++;
break;
}
case SQLITE_BUSY:
/* nothing to do */
break;
case SQLITE_DONE:
GDA_DATA_SELECT (model)->advertized_nrows = model->priv->next_row_num;
SQLITE3_CALL (sqlite3_reset) (ps->sqlite_stmt);
break;
case SQLITE_READONLY:
case SQLITE_MISUSE:
g_set_error (error, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_INTERNAL_ERROR,
"%s", _("SQLite provider fatal internal error"));
break;
case SQLITE_ERROR:
default: {
GError *lerror = NULL;
SQLITE3_CALL (sqlite3_reset) (ps->sqlite_stmt);
if (rc == SQLITE_IOERR_TRUNCATE)
g_set_error (&lerror, GDA_DATA_MODEL_ERROR,
GDA_DATA_MODEL_TRUNCATED_ERROR, "%s", _("Truncated data"));
else
g_set_error (&lerror, GDA_SERVER_PROVIDER_ERROR,
GDA_SERVER_PROVIDER_INTERNAL_ERROR,
"%s", SQLITE3_CALL (sqlite3_errmsg) (cdata->connection));
gda_data_select_add_exception (GDA_DATA_SELECT (model), lerror);
if (rc == SQLITE_ERROR)
g_propagate_error (error, g_error_copy (lerror));
GDA_DATA_SELECT (model)->advertized_nrows = model->priv->next_row_num;
break;
}
}
virt_cnc_set_working_obj (gda_data_select_get_connection ((GdaDataSelect*) model), NULL);
return prow;
}
/**
* gda_data_model_array_copy_model_ext:
* @src: a #GdaDataModel to copy data from
* @ncols: size of @cols
* @cols: (array length=ncols): array of @src's columns to copy into the new array, not %NULL
* @error: a place to store errors, or %NULL
*
* Like gda_data_model_array_copy_model(), makes a copy of @src, but copies only some
* columns.
*
* Returns: (transfer full) (allow-none): a new data model, or %NULL if an error occurred
*
* Since: 5.2.0
*/
GdaDataModelArray *
gda_data_model_array_copy_model_ext (GdaDataModel *src, gint ncols, gint *cols, GError **error)
{
GdaDataModel *model;
gint nbfields, i;
g_return_val_if_fail (GDA_IS_DATA_MODEL (src), NULL);
g_return_val_if_fail (cols, NULL);
g_return_val_if_fail (ncols > 0, NULL);
/* check columns' validity */
nbfields = gda_data_model_get_n_columns (src);
for (i = 0; i < ncols; i++) {
if ((cols[i] < 0) || (cols[i] >= nbfields)) {
g_set_error (error, GDA_DATA_MODEL_ERROR,
GDA_DATA_MODEL_COLUMN_OUT_OF_RANGE_ERROR,
_("Column %d out of range (0-%d)"), cols[i], nbfields - 1);
return NULL;
}
}
/* initialize new model */
model = gda_data_model_array_new (ncols);
if (g_object_get_data (G_OBJECT (src), "name"))
g_object_set_data_full (G_OBJECT (model), "name", g_strdup (g_object_get_data (G_OBJECT (src), "name")), g_free);
if (g_object_get_data (G_OBJECT (src), "descr"))
g_object_set_data_full (G_OBJECT (model), "descr", g_strdup (g_object_get_data (G_OBJECT (src), "descr")), g_free);
/* map new columns */
GHashTable *hash;
hash = g_hash_table_new_full (g_int_hash, g_int_equal, g_free, NULL);
for (i = 0; i < ncols; i++) {
gint *ptr;
ptr = g_new (gint, 1);
*ptr = i;
g_hash_table_insert (hash, ptr, GINT_TO_POINTER (cols[i]));
GdaColumn *copycol, *srccol;
gchar *colid;
srccol = gda_data_model_describe_column (src, cols[i]);
copycol = gda_data_model_describe_column (model, i);
g_object_get (G_OBJECT (srccol), "id", &colid, NULL);
g_object_set (G_OBJECT (copycol), "id", colid, NULL);
g_free (colid);
gda_column_set_description (copycol, gda_column_get_description (srccol));
gda_column_set_name (copycol, gda_column_get_name (srccol));
gda_column_set_dbms_type (copycol, gda_column_get_dbms_type (srccol));
gda_column_set_g_type (copycol, gda_column_get_g_type (srccol));
gda_column_set_position (copycol, gda_column_get_position (srccol));
gda_column_set_allow_null (copycol, gda_column_get_allow_null (srccol));
}
if (! gda_data_model_import_from_model (model, src, FALSE, hash, error)) {
g_hash_table_destroy (hash);
g_object_unref (model);
model = NULL;
}
/*else
gda_data_model_dump (model, stdout);*/
g_hash_table_destroy (hash);
return (GdaDataModelArray*) model;
}
static void
extract_named_parameters (GdaServerOperation *op, const gchar *root_path, GtkTextBuffer *tbuffer)
{
GdaServerOperationNode *node;
GtkTextIter iter;
gchar *str;
node = gda_server_operation_get_node_info (op, root_path);
g_return_if_fail (node);
gtk_text_buffer_get_end_iter (tbuffer, &iter);
gtk_text_buffer_insert (tbuffer, &iter, " * ", -1);
if (node->status == GDA_SERVER_OPERATION_STATUS_REQUIRED)
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "req_pathname", NULL);
else
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, root_path, -1, "opt_pathname", NULL);
gtk_text_buffer_insert (tbuffer, &iter, " (", -1);
switch (node->type) {
case GDA_SERVER_OPERATION_NODE_PARAMLIST: {
GSList *params;
str = g_strdup_printf ("GdaSet @%p)\n", node->plist);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
g_free (str);
for (params = node->plist->holders; params; params = params->next) {
gchar *npath;
npath = g_strdup_printf ("%s/%s", root_path, gda_holder_get_id (GDA_HOLDER (params->data)));
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
break;
}
case GDA_SERVER_OPERATION_NODE_DATA_MODEL: {
gint i, ncols;
str = g_strdup_printf ("GdaDataModel @%p)\n", node->model);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
g_free (str);
ncols = gda_data_model_get_n_columns (node->model);
for (i = 0; i < ncols; i++) {
GdaColumn *col = gda_data_model_describe_column (node->model, i);
gchar *npath, *str;
g_object_get (G_OBJECT (col), "id", &str, NULL);
npath = g_strdup_printf ("%s/@%s", root_path, str);
g_free (str);
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
break;
}
case GDA_SERVER_OPERATION_NODE_PARAM: {
gchar *str;
const GValue *value;
gtk_text_buffer_insert (tbuffer, &iter, "GdaHolder) = ", -1);
value = gda_holder_get_value (node->param);
str = gda_value_stringify (value);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
gtk_text_buffer_insert (tbuffer, &iter, "\n", -1);
g_free (str);
break;
}
case GDA_SERVER_OPERATION_NODE_SEQUENCE: {
gtk_text_buffer_insert (tbuffer, &iter, "Sequence)\n", -1);
guint i, size = gda_server_operation_get_sequence_size (op, root_path);
for (i = 0; i < size; i++) {
gchar **names;
names = gda_server_operation_get_sequence_item_names (op, root_path);
guint n;
for (n = 0; names [n]; n++) {
gchar *npath;
npath = g_strdup_printf ("%s/%u%s", root_path, i, names [n]);
extract_named_parameters (op, npath, tbuffer);
g_free (npath);
}
g_strfreev (names);
}
break;
}
case GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM:
gtk_text_buffer_insert (tbuffer, &iter, "Sequence item)\n", -1);
break;
case GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN: {
gint j, nrows;
gtk_text_buffer_insert (tbuffer, &iter, "Model column)\n", -1);
nrows = gda_data_model_get_n_rows (node->model);
for (j = 0; j < nrows; j++) {
gchar *npath, *str;
const GValue *value;
npath = g_strdup_printf ("%s/%d", root_path, j);
value = gda_data_model_get_value_at (node->model, gda_column_get_position (node->column), j, NULL);
if (value)
str = gda_value_stringify (value);
else
str = g_strdup ("Error: could not read data model's value");
gtk_text_buffer_insert (tbuffer, &iter, " * ", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, &iter, npath, -1, "opt_pathname", NULL);
g_free (npath);
gtk_text_buffer_insert (tbuffer, &iter, " (GValue) = ", -1);
gtk_text_buffer_insert (tbuffer, &iter, str, -1);
gtk_text_buffer_insert (tbuffer, &iter, "\n", -1);
g_free (str);
}
break;
}
default:
gtk_text_buffer_insert (tbuffer, &iter, "???", -1);
break;
}
}
