static GdaColumn *
gda_data_model_array_describe_column (GdaDataModel *model, gint col)
{
GdaColumn *column;
if (col >= gda_data_model_get_n_columns (model)) {
g_warning ("Column %d out of range (0-%d)", col, gda_data_model_get_n_columns (model) - 1);
return NULL;
}
gint tmp;
tmp = col;
column = g_hash_table_lookup (((GdaDataModelArray*) model)->priv->column_spec, &tmp);
if (!column) {
column = gda_column_new ();
g_signal_connect (G_OBJECT (column), "g-type-changed",
G_CALLBACK (column_g_type_changed_cb), model);
gda_column_set_position (column, col);
gint *ptr;
ptr = g_new (gint, 1);
*ptr = col;
g_hash_table_insert (((GdaDataModelArray*) model)->priv->column_spec, ptr, column);
}
return column;
}
/**
* gda_column_copy:
* @column: column to get a copy from.
*
* Creates a new #GdaColumn object from an existing one.
*
* Returns: (transfer full): a newly allocated #GdaColumn with a copy of the data
* in @column.
*/
GdaColumn *
gda_column_copy (GdaColumn *column)
{
GdaColumn *column_copy;
g_return_val_if_fail (GDA_IS_COLUMN (column), NULL);
column_copy = gda_column_new ();
column_copy->priv->defined_size = column->priv->defined_size;
if (column->priv->id)
column_copy->priv->id = g_strdup (column->priv->id);
column_copy->priv->g_type = column->priv->g_type;
column_copy->priv->allow_null = column->priv->allow_null;
column_copy->priv->auto_increment = column->priv->auto_increment;
column_copy->priv->auto_increment_start = column->priv->auto_increment_start;
column_copy->priv->auto_increment_step = column->priv->auto_increment_step;
column_copy->priv->position = column->priv->position;
if (column->priv->default_value)
column_copy->priv->default_value = gda_value_copy (column->priv->default_value);
gda_attributes_manager_copy (_gda_column_attributes_manager, (gpointer) column, _gda_column_attributes_manager, (gpointer) column_copy);
return column_copy;
}
/*
* the @ps struct is modified and transferred to the new data model created in
* this function
*
* See MySQL's documentation "C API Prepared Statement Type Codes":
* http://docs.oracle.com/cd/E17952_01/refman-5.5-en/c-api-prepared-statement-type-codes.html
*/
GdaDataModel *
gda_mysql_recordset_new (GdaConnection *cnc,
GdaMysqlPStmt *ps,
GdaSet *exec_params,
GdaDataModelAccessFlags flags,
GType *col_types)
{
GdaMysqlRecordset *model;
MysqlConnectionData *cdata;
gint i;
GdaDataModelAccessFlags rflags;
g_return_val_if_fail (GDA_IS_CONNECTION (cnc), NULL);
g_return_val_if_fail (ps != NULL, NULL);
cdata = (MysqlConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);
if (!cdata)
return NULL;
g_assert (ps->mysql_stmt);
/* make sure @ps reports the correct number of columns using the API*/
if (_GDA_PSTMT (ps)->ncols < 0)
_GDA_PSTMT(ps)->ncols = mysql_stmt_field_count (ps->mysql_stmt);
/* completing @ps if not yet done */
g_assert (! ps->stmt_used);
ps->stmt_used = TRUE;
if (!_GDA_PSTMT (ps)->types && (_GDA_PSTMT (ps)->ncols > 0)) {
/* create prepared statement's columns */
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->tmpl_columns = g_slist_prepend (_GDA_PSTMT (ps)->tmpl_columns,
gda_column_new ());
_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
/* create prepared statement's types, all types are initialized to GDA_TYPE_NULL */
_GDA_PSTMT (ps)->types = g_new (GType, _GDA_PSTMT (ps)->ncols);
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->types [i] = GDA_TYPE_NULL;
if (col_types) {
for (i = 0; ; i++) {
if (col_types [i] > 0) {
if (col_types [i] == G_TYPE_NONE)
break;
if (i >= _GDA_PSTMT (ps)->ncols) {
g_warning (_("Column %d out of range (0-%d), ignoring its specified type"), i,
_GDA_PSTMT (ps)->ncols - 1);
break;
}
else
_GDA_PSTMT (ps)->types [i] = col_types [i];
}
}
}
}
/* get rid of old bound result if any */
if (ps->mysql_bind_result) {
gint i;
for (i = 0; i < ((GdaPStmt *) ps)->ncols; ++i) {
g_free (ps->mysql_bind_result[i].buffer);
g_free (ps->mysql_bind_result[i].is_null);
g_free (ps->mysql_bind_result[i].length);
}
g_free (ps->mysql_bind_result);
ps->mysql_bind_result = NULL;
}
/* fill bind result */
MYSQL_RES *mysql_res = mysql_stmt_result_metadata (ps->mysql_stmt);
MYSQL_FIELD *mysql_fields = mysql_fetch_fields (mysql_res);
MYSQL_BIND *mysql_bind_result = g_new0 (MYSQL_BIND, GDA_PSTMT (ps)->ncols);
GSList *list;
for (i=0, list = _GDA_PSTMT (ps)->tmpl_columns;
i < GDA_PSTMT (ps)->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 = _GDA_PSTMT(ps)->types[i];
if (gtype == GDA_TYPE_NULL) {
gtype = _gda_mysql_type_to_gda (cdata, field->type, field->charsetnr);
_GDA_PSTMT(ps)->types[i] = gtype;
}
gda_column_set_g_type (column, gtype);
gda_column_set_name (column, field->name);
gda_column_set_description (column, field->name);
/* binding results with types */
mysql_bind_result[i].buffer_type = field->type;
mysql_bind_result[i].is_unsigned = field->flags & UNSIGNED_FLAG ? TRUE : FALSE;
mysql_bind_result[i].is_null = g_malloc0 (sizeof (my_bool));
switch (mysql_bind_result[i].buffer_type) {
case MYSQL_TYPE_TINY:
mysql_bind_result[i].buffer = g_malloc0 (sizeof (signed char));
break;
case MYSQL_TYPE_SHORT:
mysql_bind_result[i].buffer = g_malloc0 (sizeof (short int));
break;
case MYSQL_TYPE_INT24:
case MYSQL_TYPE_LONG:
case MYSQL_TYPE_YEAR:
mysql_bind_result[i].buffer = g_malloc0 (sizeof (int));
break;
case MYSQL_TYPE_LONGLONG:
mysql_bind_result[i].buffer = g_malloc0 (sizeof (long long));
break;
case MYSQL_TYPE_NULL:
break;
case MYSQL_TYPE_TIME:
case MYSQL_TYPE_DATE:
case MYSQL_TYPE_DATETIME:
case MYSQL_TYPE_TIMESTAMP:
mysql_bind_result[i].buffer = g_malloc0 (sizeof (MYSQL_TIME));
break;
case MYSQL_TYPE_FLOAT:
case MYSQL_TYPE_DOUBLE:
mysql_bind_result[i].buffer = g_malloc0 (sizeof (double));
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_DECIMAL:
case MYSQL_TYPE_NEWDECIMAL:
case MYSQL_TYPE_BIT:
mysql_bind_result[i].buffer = g_malloc0 (field->max_length + 1);
mysql_bind_result[i].buffer_length = field->max_length + 1;
mysql_bind_result[i].length = g_malloc0 (sizeof (unsigned long));
break;
default:
g_warning (_("Invalid column bind data type. %d\n"),
mysql_bind_result[i].buffer_type);
}
/*g_print ("%s(): NAME=%s, TYPE=%d, GTYPE=%s, unsigned: %d\n",
__FUNCTION__, field->name, field->type, g_type_name (gtype),
field->flags & UNSIGNED_FLAG);*/
}
if (mysql_stmt_bind_result (ps->mysql_stmt, mysql_bind_result)) {
g_warning ("mysql_stmt_bind_result failed: %s\n",
mysql_stmt_error (ps->mysql_stmt));
}
mysql_free_result (mysql_res);
ps->mysql_bind_result = mysql_bind_result;
/* 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,
"prepared-stmt", ps,
"model-usage", rflags,
"exec-params", exec_params,
NULL);
model->priv->cnc = cnc;
g_object_ref (G_OBJECT(cnc));
model->priv->mysql_stmt = ps->mysql_stmt;
((GdaDataSelect *) model)->advertized_nrows = mysql_stmt_affected_rows (ps->mysql_stmt);
return GDA_DATA_MODEL (model);
}
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);
}
static void
data_model_errors_init (DataModelErrors *model,
G_GNUC_UNUSED DataModelErrorsClass *klass)
{
gsize i;
g_return_if_fail (IS_DATA_MODEL_ERRORS (model));
model->priv = g_new0 (DataModelErrorsPrivate, 1);
/* columns */
model->priv->columns = NULL;
for (i = 0; i < NCOLS; i++) {
GdaColumn *col;
gchar *str;
col = gda_column_new ();
gda_column_set_g_type (col, G_TYPE_STRING);
str = g_strdup_printf ("col%" G_GSIZE_FORMAT, i);
gda_column_set_name (col, str);
gda_column_set_description (col, str);
g_object_set (G_OBJECT (col), "id", str, NULL);
g_free (str);
model->priv->columns = g_slist_append (model->priv->columns, col);
}
/* rows */
model->priv->rows = g_ptr_array_new (); /* array of GdaRow pointers */
for (i = 0; i < (sizeof (data) / sizeof (ARow)); i++) {
ARow *arow = &(data[i]);
GdaRow *row = gda_row_new (NCOLS);
GValue *value;
value = gda_row_get_value (row, 0);
if (arow->col0) {
if (*arow->col0 == '-')
G_VALUE_TYPE (value) = G_TYPE_INVALID;
else {
gda_value_reset_with_type (value, G_TYPE_STRING);
g_value_set_string (value, arow->col0);
}
}
value = gda_row_get_value (row, 1);
if (arow->col1) {
if (*arow->col1 == '-')
G_VALUE_TYPE (value) = G_TYPE_INVALID;
else {
gda_value_reset_with_type (value, G_TYPE_STRING);
g_value_set_string (value, arow->col1);
}
}
value = gda_row_get_value (row, 2);
if (arow->col2) {
if (*arow->col2 == '-')
G_VALUE_TYPE (value) = G_TYPE_INVALID;
else {
gda_value_reset_with_type (value, G_TYPE_STRING);
g_value_set_string (value, arow->col2);
}
}
value = gda_row_get_value (row, 3);
if (arow->col3) {
if (*arow->col3 == '-')
G_VALUE_TYPE (value) = G_TYPE_INVALID;
else {
gda_value_reset_with_type (value, G_TYPE_STRING);
g_value_set_string (value, arow->col3);
}
}
g_ptr_array_add (model->priv->rows, row);
}
}
/*
* the @ps struct is modified and transferred to the new data model created in
* this function
*/
GdaDataModel *
gda_oracle_recordset_new (GdaConnection *cnc, GdaOraclePStmt *ps, GdaSet *exec_params,
GdaDataModelAccessFlags flags, GType *col_types)
{
GdaOracleRecordset *model;
OracleConnectionData *cdata;
gint i;
GdaDataModelAccessFlags rflags;
gint nb_rows = -1;
g_return_val_if_fail (GDA_IS_CONNECTION (cnc), NULL);
g_return_val_if_fail (ps != NULL, NULL);
cdata = (OracleConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);
if (!cdata)
return NULL;
/* make sure @ps reports the correct number of columns using the API */
if (_GDA_PSTMT (ps)->ncols < 0) {
ub4 ncolumns;
int result;
/* get the number of columns in the result set */
result = OCIAttrGet ((dvoid *) ps->hstmt,
(ub4) OCI_HTYPE_STMT,
(dvoid *) &ncolumns,
(ub4 *) 0,
(ub4) OCI_ATTR_PARAM_COUNT,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the number of columns in the result set")))
return NULL;
_GDA_PSTMT (ps)->ncols = ncolumns;
}
/* completing @ps if not yet done */
if (!_GDA_PSTMT (ps)->types && (_GDA_PSTMT (ps)->ncols > 0)) {
/* create prepared statement's columns */
GSList *list;
GList *ora_values = NULL;
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->tmpl_columns = g_slist_prepend (_GDA_PSTMT (ps)->tmpl_columns,
gda_column_new ());
_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
/* create prepared statement's types, all types are initialized to GDA_TYPE_NULL */
_GDA_PSTMT (ps)->types = g_new (GType, _GDA_PSTMT (ps)->ncols);
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->types [i] = GDA_TYPE_NULL;
if (col_types) {
for (i = 0; ; i++) {
if (col_types [i] > 0) {
if (col_types [i] == G_TYPE_NONE)
break;
if (i >= _GDA_PSTMT (ps)->ncols) {
g_warning (_("Column %d out of range (0-%d), ignoring its specified type"), i,
_GDA_PSTMT (ps)->ncols - 1);
break;
}
else
_GDA_PSTMT (ps)->types [i] = col_types [i];
}
}
}
/* fill GdaColumn's data and define the GdaOracleValue structures */
for (i=0, list = _GDA_PSTMT (ps)->tmpl_columns;
i < GDA_PSTMT (ps)->ncols;
i++, list = list->next) {
GdaColumn *column;
int result;
GdaOracleValue *ora_value;
gboolean use_callback = FALSE;
ora_value = g_new0 (GdaOracleValue, 1);
ora_values = g_list_prepend (ora_values, ora_value);
/* parameter to get attributes */
result = OCIParamGet (ps->hstmt,
OCI_HTYPE_STMT,
cdata->herr,
(dvoid **) &(ora_value->pard),
(ub4) i+1);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the Oracle parameter descripter in the result set"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
/* data size */
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->defined_size),
0,
(ub4) OCI_ATTR_DATA_SIZE,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the parameter defined size"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
ora_value->defined_size++;
/* data type */
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->sql_type),
0,
OCI_ATTR_DATA_TYPE,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the parameter data type"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->precision),
0,
OCI_ATTR_PRECISION,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the type's precision"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
result = OCIAttrGet ((dvoid *) (ora_value->pard),
OCI_DTYPE_PARAM,
&(ora_value->scale),
0,
OCI_ATTR_SCALE,
cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get the type's scale"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
/* column's name */
text *name;
ub4 name_len;
column = GDA_COLUMN (list->data);
result = OCIAttrGet ((dvoid *) (ora_value->pard),
(ub4) OCI_DTYPE_PARAM,
(dvoid **) &name,
(ub4 *) &name_len,
(ub4) OCI_ATTR_NAME,
(OCIError *) cdata->herr);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not get column name in the result set"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
gchar *name_buffer;
name_buffer = g_new (gchar, name_len + 1);
memcpy (name_buffer, name, name_len);
name_buffer [name_len] = '\0';
gda_column_set_name (column, name_buffer);
gda_column_set_description (column, name_buffer);
g_free (name_buffer);
/* for data fetching */
if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
ora_value->sql_type = _g_type_to_oracle_sqltype (_GDA_PSTMT (ps)->types [i]);
switch (ora_value->sql_type) {
case SQLT_CHR: /* for G_TYPE_STRING => request SQLT_CHR */
case SQLT_STR:
case SQLT_VCS:
case SQLT_RID:
case SQLT_AVC:
case SQLT_AFC:
ora_value->sql_type = SQLT_CHR;
if (ora_value->defined_size == 1)
use_callback = TRUE;
break;
case SQLT_INT:
ora_value->defined_size = sizeof (gint);
break;
case SQLT_FLT:
case SQLT_BFLOAT:
ora_value->defined_size = sizeof (gfloat);
break;
case SQLT_BDOUBLE:
ora_value->defined_size = sizeof (gdouble);
break;
case SQLT_DAT: /* request OCIDate */
ora_value->sql_type = SQLT_ODT;
break;
case SQLT_NUM: /* for GDA_TYPE_NUMERIC => request SQLT_CHR */
case SQLT_VNU:
ora_value->sql_type = SQLT_CHR;
break;
case SQLT_LBI:
case SQLT_LVB:
case SQLT_LVC:
case SQLT_LNG:
case SQLT_VBI:
case SQLT_BIN:
use_callback = TRUE;
break;
default:
use_callback = TRUE;
break;
}
if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
ora_value->g_type = _GDA_PSTMT (ps)->types [i];
else
ora_value->g_type = _oracle_sqltype_to_g_type (ora_value->sql_type, ora_value->precision,
ora_value->scale);
if (ora_value->g_type == GDA_TYPE_BLOB) {
/* allocate a Lob locator */
OCILobLocator *lob;
result = OCIDescriptorAlloc ((dvoid *) cdata->henv, (dvoid **) &lob,
(ub4) gda_oracle_blob_type (ora_value->sql_type),
(size_t) 0, (dvoid **) 0);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not allocate Lob locator"))) {
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
ora_value->value = lob;
ora_value->defined_size = 0;
}
else if (use_callback) {
ora_value->value = NULL;
ora_value->defined_size = 33554432; /* 32M */
}
else
ora_value->value = g_malloc0 (ora_value->defined_size);
ora_value->s_type = gda_g_type_to_static_type (ora_value->g_type);
if (_GDA_PSTMT (ps)->types [i] == GDA_TYPE_NULL)
_GDA_PSTMT (ps)->types [i] = ora_value->g_type;
gda_column_set_g_type (column, ora_value->g_type);
#ifdef GDA_DEBUG_NO
g_print ("**COL type is %d, GType is %s, ORA defined size is %d%s\n",
ora_value->sql_type,
g_type_name (ora_value->g_type),
ora_value->defined_size - 1,
use_callback ? " using callback": "");
#endif
ora_value->hdef = (OCIDefine *) 0;
ora_value->indicator = 0;
result = OCIDefineByPos ((OCIStmt *) ps->hstmt,
(OCIDefine **) &(ora_value->hdef),
(OCIError *) cdata->herr,
(ub4) i + 1,
ora_value->value,
ora_value->defined_size,
ora_value->sql_type,
(dvoid *) &(ora_value->indicator),
&(ora_value->rlen),
&(ora_value->rcode),
(ub4) (use_callback ? OCI_DYNAMIC_FETCH : OCI_DEFAULT));
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not define by position"))) {
OCIDescriptorFree ((dvoid *) ora_value->pard, OCI_DTYPE_PARAM);
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
if (use_callback) {
result = OCIDefineDynamic ((OCIDefine *) (ora_value->hdef),
(OCIError *) (cdata->herr),
(dvoid*) (ora_value),
(OCICallbackDefine) ora_def_callback);
if (gda_oracle_check_result (result, cnc, cdata, OCI_HTYPE_ERROR,
_("Could not define by position"))) {
OCIDescriptorFree ((dvoid *) ora_value->pard, OCI_DTYPE_PARAM);
g_list_foreach (ora_values, (GFunc) _gda_oracle_value_free, NULL);
return NULL;
}
}
ora_value->use_callback = use_callback;
}
ps->ora_values = g_list_reverse (ora_values);
}
/* determine access mode: RANDOM or CURSOR FORWARD are the only supported; if CURSOR BACKWARD
* is requested, then we need RANDOM mode */
if (flags & GDA_DATA_MODEL_ACCESS_RANDOM)
rflags = GDA_DATA_MODEL_ACCESS_RANDOM;
else if (flags & GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD)
rflags = GDA_DATA_MODEL_ACCESS_RANDOM;
else
rflags = GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD;
ub4 prefetch;
prefetch = (ub4) (100);
OCIAttrSet (ps->hstmt, OCI_HTYPE_STMT,
&prefetch, 0,
OCI_ATTR_PREFETCH_ROWS, cdata->herr);
/* create data model */
model = g_object_new (GDA_TYPE_ORACLE_RECORDSET,
"connection", cnc,
"prepared-stmt", ps,
"model-usage", rflags,
"exec-params", exec_params, NULL);
GDA_DATA_SELECT (model)->advertized_nrows = nb_rows;
return GDA_DATA_MODEL (model);
}
/*
* the @ps struct is modified and transferred to the new data model created in
* this function
*/
GdaDataModel *
_gda_sqlite_recordset_new (GdaConnection *cnc, GdaSqlitePStmt *ps, GdaSet *exec_params,
GdaDataModelAccessFlags flags, GType *col_types, gboolean force_empty)
{
GdaSqliteRecordset *model;
SqliteConnectionData *cdata;
gint i;
GdaDataModelAccessFlags rflags;
g_return_val_if_fail (GDA_IS_CONNECTION (cnc), NULL);
g_return_val_if_fail (ps != NULL, NULL);
cdata = (SqliteConnectionData*) gda_connection_internal_get_provider_data_error (cnc, NULL);
if (!cdata)
return NULL;
if (!cdata->types_hash)
_gda_sqlite_compute_types_hash (cdata);
/* make sure @ps reports the correct number of columns */
if (_GDA_PSTMT (ps)->ncols < 0)
_GDA_PSTMT (ps)->ncols = SQLITE3_CALL (sqlite3_column_count) (ps->sqlite_stmt) -
ps->nb_rowid_columns;
/* completing ps */
g_assert (! ps->stmt_used);
ps->stmt_used = TRUE;
if (!_GDA_PSTMT (ps)->types && (_GDA_PSTMT (ps)->ncols > 0)) {
/* create prepared statement's columns */
GSList *list;
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->tmpl_columns = g_slist_prepend (_GDA_PSTMT (ps)->tmpl_columns,
gda_column_new ());
_GDA_PSTMT (ps)->tmpl_columns = g_slist_reverse (_GDA_PSTMT (ps)->tmpl_columns);
/* create prepared statement's types, all types are initialized to GDA_TYPE_NULL */
_GDA_PSTMT (ps)->types = g_new (GType, _GDA_PSTMT (ps)->ncols);
for (i = 0; i < _GDA_PSTMT (ps)->ncols; i++)
_GDA_PSTMT (ps)->types [i] = GDA_TYPE_NULL;
if (col_types) {
for (i = 0; ; i++) {
if (col_types [i] > 0) {
if (col_types [i] == G_TYPE_NONE)
break;
if (i >= _GDA_PSTMT (ps)->ncols)
g_warning (_("Column %d out of range (0-%d), ignoring its specified type"), i,
_GDA_PSTMT (ps)->ncols - 1);
else
_GDA_PSTMT (ps)->types [i] = col_types [i];
}
}
}
/* fill GdaColumn's data */
for (i=0, list = _GDA_PSTMT (ps)->tmpl_columns;
i < GDA_PSTMT (ps)->ncols;
i++, list = list->next) {
GdaColumn *column;
gint real_col = i + ps->nb_rowid_columns;
column = GDA_COLUMN (list->data);
gda_column_set_description (column, SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col));
gda_column_set_name (column, SQLITE3_CALL (sqlite3_column_name) (ps->sqlite_stmt, real_col));
gda_column_set_dbms_type (column, SQLITE3_CALL (sqlite3_column_decltype) (ps->sqlite_stmt, real_col));
if (_GDA_PSTMT (ps)->types [i] != GDA_TYPE_NULL)
gda_column_set_g_type (column, _GDA_PSTMT (ps)->types [i]);
}
}
/* determine access mode: RANDOM or CURSOR FORWARD are the only supported; if CURSOR BACKWARD
* is requested, then we need RANDOM mode */
if (flags & GDA_DATA_MODEL_ACCESS_RANDOM)
rflags = GDA_DATA_MODEL_ACCESS_RANDOM;
else if (flags & GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD)
rflags = GDA_DATA_MODEL_ACCESS_RANDOM;
else
rflags = GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD;
/* create data model */
model = g_object_new (GDA_TYPE_SQLITE_RECORDSET,
"connection", cnc,
"prepared-stmt", ps, "model-usage", rflags,
"exec-params", exec_params,
"auto-reset", force_empty, NULL);
gboolean is_virt;
is_virt = GDA_IS_VCONNECTION_DATA_MODEL (cnc) ? TRUE : FALSE;
if (is_virt) {
/* steal the lock */
_gda_vconnection_change_working_obj ((GdaVconnectionDataModel*) cnc, (GObject*) model);
_gda_vconnection_set_working_obj ((GdaVconnectionDataModel*) cnc, NULL);
}
/* fill the data model */
read_rows_to_init_col_types (model);
return GDA_DATA_MODEL (model);
}
static void
gda_data_model_dir_set_property (GObject *object,
guint param_id,
const GValue *value,
GParamSpec *pspec)
{
GdaDataModelDir *model;
const gchar *string;
model = GDA_DATA_MODEL_DIR (object);
if (model->priv) {
switch (param_id) {
case PROP_BASEDIR:
if (model->priv->basedir) {
g_free (model->priv->basedir);
model->priv->basedir = NULL;
}
string = g_value_get_string (value);
if (string)
model->priv->basedir = g_strdup (string);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
break;
}
if (model->priv->basedir) {
GdaColumn *column;
/* create columns */
model->priv->columns = NULL;
/* COL_DIRNAME */
column = gda_column_new ();
model->priv->columns = g_slist_append (model->priv->columns , column);
gda_column_set_name (column, "dir_name");
gda_column_set_description (column, "dir_name");
gda_column_set_g_type (column, G_TYPE_STRING);
/* COL_FILENAME */
column = gda_column_new ();
model->priv->columns = g_slist_append (model->priv->columns , column);
gda_column_set_name (column, "file_name");
gda_column_set_description (column, "file_name");
gda_column_set_g_type (column, G_TYPE_STRING);
/* COL_SIZE */
column = gda_column_new ();
model->priv->columns = g_slist_append (model->priv->columns , column);
gda_column_set_name (column, "size");
gda_column_set_description (column, "size");
gda_column_set_g_type (column, G_TYPE_UINT);
/* COL_MIME */
column = gda_column_new ();
model->priv->columns = g_slist_append (model->priv->columns , column);
gda_column_set_name (column, "mime_type");
gda_column_set_description (column, "mime_type");
gda_column_set_g_type (column, G_TYPE_STRING);
/* COL_MD5SUM */
column = gda_column_new ();
model->priv->columns = g_slist_append (model->priv->columns , column);
gda_column_set_name (column, "md5sum");
gda_column_set_description (column, "md5sum");
gda_column_set_g_type (column, G_TYPE_STRING);
/* COL_DATA */
column = gda_column_new ();
model->priv->columns = g_slist_append (model->priv->columns , column);
gda_column_set_name (column, "data");
gda_column_set_description (column, "data");
gda_column_set_g_type (column, GDA_TYPE_BLOB);
/* number of rows */
update_data_model (model);
}
}
}