void
_propagate_rows (MidgardSqlQueryResult *self, guint *n_objects, GError **error)
{
/* No model, no rows. Return NULL and set error */
if (self->model == NULL || self->n_rows == 0) {
g_set_error (error, MIDGARD_VALIDATION_ERROR, MIDGARD_VALIDATION_ERROR_INTERNAL,
"QueryResult holds empty data model");
return;
}
/* We have rows, so add new reference to each and return all of them */
guint i = 0;
if (self->rows != NULL) {
*n_objects = self->n_rows;
for (i = 0; i < self->n_rows; i++)
g_object_ref(self->rows[i]);
return;
}
GdaDataModel *model = GDA_DATA_MODEL (self->model);
self->n_rows = gda_data_model_get_n_rows (model);
if (self->n_rows == 0)
return ;
self->rows = g_new (MidgardSqlQueryRow*, self->n_rows);
for (i = 0; i < self->n_rows; i++) {
MidgardConnection *mgd = midgard_query_selector_get_connection (self->selector);
self->rows[i] = midgard_sql_query_row_new (mgd, G_OBJECT (model), i);
/* Row constructor holds new reference on connection, therefore decrease current one */
g_object_unref (mgd);
}
*n_objects = self->n_rows;
}
/*
* Display the contents of the 'data' data model
*/
static void
list_table_columns (GdaDataModel* data)
{
gint nrows;
nrows = gda_data_model_get_n_rows (data);
if (nrows == 0)
g_print ("No column...\n");
else {
gint i;
const GValue* col_name;
const GValue* col_type;
g_print ("Tables' columns:\n");
for (i = 0; i < nrows; ++ i) {
col_name = gda_data_model_get_value_at (data, 0, i, NULL);
g_assert (col_name);
col_type = gda_data_model_get_value_at (data, 2, i, NULL);
g_assert (col_type);
printf(" %s: %s\n", g_value_get_string (col_name), g_value_get_string (col_type));
}
}
}
/*
* GdaDataModel interface implementation
*/
static gint
gda_data_access_wrapper_get_n_rows (GdaDataModel *model)
{
GdaDataAccessWrapper *imodel;
g_return_val_if_fail (GDA_IS_DATA_ACCESS_WRAPPER (model), 0);
imodel = (GdaDataAccessWrapper*) model;
g_return_val_if_fail (imodel->priv, 0);
if (imodel->priv->nb_rows >= 0)
return imodel->priv->nb_rows;
if (imodel->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_RANDOM)
/* imodel->priv->mode is a random access model, use it */
imodel->priv->nb_rows = gda_data_model_get_n_rows (imodel->priv->model);
else {
/* go at the end */
while (!imodel->priv->end_of_data) {
if (! gda_data_model_iter_move_next (imodel->priv->iter))
break;
}
if (imodel->priv->end_of_data)
imodel->priv->nb_rows = imodel->priv->last_row +1;
else
imodel->priv->nb_rows = -1;
}
return imodel->priv->nb_rows;
}
/*
* run_context_push
*
* Add a new run context level below @context, running @stmt to create a data model
*/
static RunContext *
run_context_push_with_stmt (GdaReportEngine *engine, RunContext *context, GdaConnection *cnc,
GdaStatement *stmt, const gchar *stmt_name, GError **error)
{
GdaDataModel *model;
GdaSet *plist;
GdaStatement *lstmt;
lstmt = rewrite_statement (engine, context, stmt, error);
if (!lstmt)
return NULL;
g_assert (cnc);
if (!gda_statement_get_parameters (lstmt, &plist, error)) {
g_object_unref (lstmt);
return NULL;
}
if (plist && !assign_parameters_values (engine, context, plist, error)) {
g_object_unref (plist);
g_object_unref (lstmt);
return NULL;
}
model = gda_connection_statement_execute_select (cnc, lstmt, plist, error);
if (plist)
g_object_unref (plist);
g_object_unref (lstmt);
if (!model)
return NULL;
g_object_set_data_full (G_OBJECT (model), "name", g_strdup (stmt_name), g_free);
/* add a parameter for the number of rows, attached to model */
GdaHolder *param;
GValue *value;
gchar *name;
param = gda_holder_new (G_TYPE_INT);
value = gda_value_new (G_TYPE_INT);
g_value_set_int (value, gda_data_model_get_n_rows (model));
if (! gda_holder_set_value (param, value, error)) {
g_object_unref (param);
gda_value_free (value);
return NULL;
}
gda_value_free (value);
name = g_strdup_printf ("%s|?nrows", stmt_name);
g_object_set_data_full (G_OBJECT (model), name, param, g_object_unref);
g_free (name);
/* create a new RunContext */
RunContext *ctx;
ctx = g_new0 (RunContext, 1);
ctx->stmt = NULL;
ctx->cnc = cnc;
ctx->parent = context;
ctx->model = model;
ctx->iter = gda_data_model_create_iter (model);
/*g_print (">>>> PUSH CONTEXT %p\n", ctx);*/
return ctx;
}
int
main (int argc, char *argv [])
{
GdaDataModel *model;
gint i, nrows;
GError *error = NULL;
gda_init ();
model = g_object_new (TYPE_CUSTOM_DATA_MODEL, "filename", DATABASE, NULL);
gda_data_model_dump (model, stdout);
nrows = gda_data_model_get_n_rows (model);
i = gda_data_model_append_row (model, &error);
if (i < 0) {
g_print ("Could not append row: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
else {
GValue *value;
GdaBinary bin;
Key m_key;
Value m_value;
strncpy (m_key.color, "black", COLORSIZE);
m_key.type = 100;
bin.data = (gpointer) &m_key;
bin.binary_length = sizeof (Key);
value = gda_value_new (GDA_TYPE_BINARY);
gda_value_set_binary (value, &bin);
if (!gda_data_model_set_value_at (model, 0, i, value, &error)) {
g_print ("Could not set key: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_value_free (value);
m_value.size = 100.1;
strncpy (m_value.name, "blackhole", NAMESIZE);
bin.data = (gpointer) &m_value;
bin.binary_length = sizeof (Value);
value = gda_value_new (GDA_TYPE_BINARY);
gda_value_set_binary (value, &bin);
if (!gda_data_model_set_value_at (model, 1, i, value, &error)) {
g_print ("Could not set key: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_value_free (value);
}
g_object_unref (model);
return 0;
}
/*
* GdaDataModel interface implementation
*/
static gint
gda_data_meta_wrapper_get_n_rows (GdaDataModel *model)
{
GdaDataMetaWrapper *imodel;
g_return_val_if_fail (GDA_IS_DATA_META_WRAPPER (model), 0);
imodel = GDA_DATA_META_WRAPPER (model);
g_return_val_if_fail (imodel->priv, 0);
return gda_data_model_get_n_rows (imodel->priv->model);
}
int
main (int argc, char** argv)
{
gchar *file;
GError *error = NULL;
GdaDataModel *model;
guint i, nrows;
guint nfailed = 0;
gda_init ();
/* generic parser */
GdaSqlParser *parser;
parser = gda_sql_parser_new ();
nfailed += do_a_test (NULL, parser);
g_object_unref (parser);
/* test other parsers only if generic one is Ok */
if (nfailed == 0) {
model = gda_config_list_providers ();
nrows = gda_data_model_get_n_rows (model);
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
cvalue = gda_data_model_get_value_at (model, 0, i, NULL);
g_assert (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING));
if (!g_ascii_strcasecmp (g_value_get_string (cvalue), "Oracle"))
continue; /* ignore Oracle for now */
g_print ("Testing database provider '%s'\n", g_value_get_string (cvalue));
GdaServerProvider *prov;
prov = gda_config_get_provider (g_value_get_string (cvalue), NULL);
g_assert (prov);
GdaSqlParser *parser;
parser = gda_server_provider_create_parser (prov, NULL);
if (!parser)
parser = gda_sql_parser_new ();
nfailed += do_a_test (prov, parser);
g_object_unref (parser);
}
g_object_unref (model);
}
if (nfailed == 0) {
g_print ("Ok\n");
return EXIT_SUCCESS;
}
else {
g_print ("%u failed\n", nfailed);
return EXIT_FAILURE;
}
}
/**
* @return -1 on error
*/
gint
symbol_db_engine_iterator_get_n_items (SymbolDBEngineIterator *dbi)
{
SymbolDBEngineIteratorPriv *priv;
g_return_val_if_fail (dbi != NULL, -1);
priv = dbi->priv;
if (priv->total_rows < 0)
{
/* try to get the number of rows */
priv->total_rows = gda_data_model_get_n_rows (priv->data_model);
}
return priv->total_rows;
}
/**
* gda_provider_meta_execute_query_row:
* @prov: a #GdaProviderMeta
* @sql: a string with the SQL to execute on provider
* @error: place to store errors or %NULL
*
* SQL is specific for current provider.
*
* Returns: (transfer full) (nullable): a new #GdaDataModel with as a result of the query
* Since: 6.0
* Stability: Unstable
*/
GdaRow*
gda_provider_meta_execute_query_row (GdaProviderMeta *prov,
const gchar *sql,
GdaSet *params,
GError **error)
{
GdaDataModel *model = NULL;
model = gda_provider_meta_execute_query (prov, sql, params, error);
if (model == NULL) {
return NULL;
}
if (gda_data_model_get_n_rows (model) != 1) {
g_set_error (error, GDA_PROVIDER_META_ERROR, GDA_PROVIDER_META_NO_CONNECTION_ERROR,
_("No rows or more than one row was returned from query"));
return NULL;
}
return gda_row_new_from_data_model (model, 0);
}
/**
* oseaserver_command_get_dataset:
* @datamodel: A GdaDataModel to extract data from.
*
* Convenienve function to translate a given @datamodel into a
* CoyoteDataSet structure.
*
* Return value: A translated CoyoteDataSet or NULL if fails.
**/
CoyoteDataSet * oseaserver_command_get_dataset (GdaDataModel * datamodel)
{
gint rows, columns, i, j;
CoyoteDataSet * result;
GdaValue * value = NULL;
gchar * str_value = NULL;
g_return_val_if_fail (datamodel, NULL);
rows = gda_data_model_get_n_rows (datamodel);
columns = gda_data_model_get_n_columns (datamodel);
result = coyote_dataset_new ();
for (i = 0; i < rows; i++) {
for (j = 0; j < columns; j ++) {
value = gda_value_copy ( gda_data_model_get_value_at (datamodel, j, i) );
str_value = gda_value_stringify (value);
coyote_dataset_add (result, str_value);
g_free (str_value);
if (value->type != GDA_VALUE_TYPE_NUMERIC)
gda_value_free (value);
else {
#warning We must remove this if when gda fix its gda_value_copy bug
}
}
if (i == (rows - 1))
break;
coyote_dataset_new_row (result);
}
return result;
}
static void
_midgard_sql_query_result_set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
MidgardSqlQueryResult *self = MIDGARD_SQL_QUERY_RESULT (object);
switch (property_id) {
case PROPERTY_MODEL:
self->model = g_value_dup_object (value);
self->n_columns = gda_data_model_get_n_columns (GDA_DATA_MODEL (self->model));
self->n_rows = gda_data_model_get_n_rows (GDA_DATA_MODEL (self->model));
break;
case PROPERTY_SELECTOR:
self->selector = g_value_dup_object (value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (self, property_id, pspec);
break;
}
}
void
sim_xml_config_set_config_max_event_tmp (SimConfig *config)
{
GdaDataModel *dm;
GdaValue *value;
gchar *query;
g_return_if_fail (config);
g_return_if_fail (SIM_IS_CONFIG (config));
query = g_strdup_printf ("SELECT value FROM config WHERE conf='max_event_tmp'");
dm = sim_database_execute_single_command (ossim.ossimdb, query);
if (dm)
{
value = (GdaValue *) gda_data_model_get_value_at (dm, 0, 0);
if (gda_data_model_get_n_rows(dm) !=0) //to avoid (null)-Critical: gda_value_is_null: assertion `value != NULL' failed
{
if (!gda_value_is_null (value))
{
config->max_event_tmp = gda_value_stringify (value);
}
else
g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "sim_xml_config_set_config_max_event_tmp value null");
}
else
config->max_event_tmp = 0;
}
else
{
g_message ("Error: Config DATA MODEL ERROR");
config->max_event_tmp = 0;
}
g_free (query);
}
GPtrArray *
symbol_db_util_get_files_with_zero_symbols (SymbolDBEngine *dbe)
{
SymbolDBEnginePriv *priv;
GdaDataModel *data_model;
GPtrArray *files_to_scan;
const GdaStatement *stmt;
gint i, num_rows = 0;
g_return_val_if_fail (dbe != NULL, NULL);
priv = dbe->priv;
SDB_LOCK(priv);
if ((stmt = sdb_engine_get_statement_by_query_id (dbe,
PREP_QUERY_GET_ALL_FROM_FILE_WHERE_NOT_IN_SYMBOLS))
== NULL)
{
SDB_UNLOCK(priv);
return NULL;
}
data_model = gda_connection_statement_execute_select (priv->db_connection,
(GdaStatement*)stmt,
NULL, NULL);
if (!GDA_IS_DATA_MODEL (data_model) ||
(num_rows = gda_data_model_get_n_rows (GDA_DATA_MODEL (data_model))) <= 0)
{
if (data_model != NULL)
g_object_unref (data_model);
SDB_UNLOCK(priv);
return NULL;
}
/* initialize the array */
files_to_scan = g_ptr_array_new_with_free_func (g_free);
/* we can now scan each filename entry to check the last modification time. */
for (i = 0; i < num_rows; i++)
{
const GValue *value;
const gchar *file_name;
gchar *file_abs_path = NULL;
if ((value =
gda_data_model_get_value_at (data_model,
gda_data_model_get_column_index(data_model, "db_file_path"),
i, NULL)) == NULL)
{
continue;
}
/* build abs path. */
file_name = g_value_get_string (value);
file_abs_path = symbol_db_util_get_full_local_path (dbe, file_name);
g_ptr_array_add (files_to_scan, file_abs_path);
}
g_object_unref (data_model);
SDB_UNLOCK(priv);
return files_to_scan;
}
gchar *
gda_postgres_render_CREATE_TABLE (GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, GError **error)
{
GString *string;
const GValue *value;
gboolean hasfields = FALSE;
gint nrows;
gint i;
gboolean first;
GSList *pkfields = NULL; /* list of GValue* composing the pkey */
gint nbpkfields = 0;
gchar *sql = NULL;
gchar *tmp;
string = g_string_new ("CREATE ");
value = gda_server_operation_get_value_at (op, "/TABLE_DEF_P/TABLE_TEMP");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "TEMP ");
g_string_append (string, "TABLE ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/TABLE_DEF_P/TABLE_NAME", error);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
g_string_append (string, " (");
/* FIELDS */
GdaServerOperationNode *node;
node = gda_server_operation_get_node_info (op, "/FIELDS_A");
g_assert (node);
/* finding if there is a composed primary key */
nrows = gda_data_model_get_n_rows (node->model);
for (i = 0; i < nrows; i++) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) {
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FIELDS_A/@COLUMN_NAME/%d", error, i);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
pkfields = g_slist_append (pkfields, tmp);
nbpkfields ++;
}
}
/* manually defined fields */
first = TRUE;
for (i = 0; i < nrows; i++) {
hasfields = TRUE;
if (first)
first = FALSE;
else
g_string_append (string, ", ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FIELDS_A/@COLUMN_NAME/%d", error, i);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
g_string_append_c (string, ' ');
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_AUTOINC/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "serial");
else {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_TYPE/%d", i);
g_string_append (string, g_value_get_string (value));
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_SIZE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_UINT)) {
g_string_append_printf (string, "(%d", g_value_get_uint (value));
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_SCALE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_UINT))
g_string_append_printf (string, ",%d)", g_value_get_uint (value));
else
g_string_append (string, ")");
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_DEFAULT/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " DEFAULT ");
g_string_append (string, str);
}
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_NNUL/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " NOT NULL");
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_UNIQUE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " UNIQUE");
if (nbpkfields == 1) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " PRIMARY KEY");
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_CHECK/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " CHECK (");
g_string_append (string, str);
g_string_append_c (string, ')');
}
}
}
/* LIKE inheritance */
nrows = gda_server_operation_get_sequence_size (op, "/TABLE_PARENTS_S");
for (i = 0; i < nrows; i++) {
value = gda_server_operation_get_value_at (op, "/TABLE_PARENTS_S/%d/TABLE_PARENT_COPY", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && !g_value_get_boolean (value)) {
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/TABLE_PARENTS_S/%d/TABLE_PARENT_TABLE",
error, i);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
hasfields = TRUE;
if (first)
first = FALSE;
else
g_string_append (string, ", ");
g_string_append (string, "LIKE ");
g_string_append (string, tmp);
value = gda_server_operation_get_value_at (op,
"/TABLE_PARENTS_S/%d/TABLE_PARENT_COPY_DEFAULTS", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) &&
g_value_get_boolean (value))
g_string_append (string, " INCLUDING DEFAULTS");
g_free (tmp);
}
}
/* composed primary key */
if (nbpkfields > 1) {
GSList *list;
g_string_append (string, ", PRIMARY KEY (");
for (list = pkfields; list; list = list->next) {
if (list != pkfields)
g_string_append (string, ", ");
g_string_append (string, (gchar*) list->data);
}
g_string_append_c (string, ')');
}
g_slist_foreach (pkfields, (GFunc) g_free, NULL);
g_slist_free (pkfields);
/* foreign keys */
first = TRUE;
node = gda_server_operation_get_node_info (op, "/FKEY_S");
if (node) {
nrows = gda_server_operation_get_sequence_size (op, "/FKEY_S");
for (i = 0; i < nrows; i++) {
gint nbfields = 0;
gint j;
g_string_append (string, ", FOREIGN KEY (");
node = gda_server_operation_get_node_info (op, "/FKEY_S/%d/FKEY_FIELDS_A", i);
if (!node || ((nbfields = gda_data_model_get_n_rows (node->model)) == 0)) {
g_string_free (string, TRUE);
g_set_error (error, GDA_SERVER_OPERATION_ERROR,
GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR,
"%s",
_("No field specified in foreign key constraint"));
return NULL;
}
else {
for (j = 0; j < nbfields; j++) {
if (j != 0)
g_string_append (string, ", ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FKEY_S/%d/FKEY_FIELDS_A/@FK_FIELD/%d",
error, i, j);
if (tmp) {
g_string_append (string, tmp);
g_free (tmp);
}
else {
g_string_free (string, TRUE);
return NULL;
}
}
}
g_string_append (string, ") REFERENCES ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FKEY_S/%d/FKEY_REF_TABLE", error, i);
if (tmp) {
g_string_append (string, tmp);
g_free (tmp);
}
else {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, " (");
for (j = 0; j < nbfields; j++) {
if (j != 0)
g_string_append (string, ", ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FKEY_S/%d/FKEY_FIELDS_A/@FK_REF_PK_FIELD/%d",
error, i, j);
if (tmp) {
g_string_append (string, tmp);
g_free (tmp);
}
else {
g_string_free (string, TRUE);
return NULL;
}
}
g_string_append_c (string, ')');
value = gda_server_operation_get_value_at (op, "/FKEY_S/%d/FKEY_MATCH_TYPE", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value))
g_string_append_printf (string, " %s", g_value_get_string (value));
value = gda_server_operation_get_value_at (op, "/FKEY_S/%d/FKEY_ONUPDATE", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value))
g_string_append_printf (string, " ON UPDATE %s", g_value_get_string (value));
value = gda_server_operation_get_value_at (op, "/FKEY_S/%d/FKEY_ONDELETE", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value))
g_string_append_printf (string, " ON DELETE %s", g_value_get_string (value));
value = gda_server_operation_get_value_at (op, "/FKEY_S/%d/FKEY_DEFERRABLE", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value))
g_string_append_printf (string, " %s", g_value_get_string (value));
}
}
g_string_append (string, ")");
/* INHERITS */
first = TRUE;
nrows = gda_server_operation_get_sequence_size (op, "/TABLE_PARENTS_S");
for (i = 0; i < nrows; i++) {
value = gda_server_operation_get_value_at (op, "/TABLE_PARENTS_S/%d/TABLE_PARENT_COPY", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) {
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/TABLE_PARENTS_S/%d/TABLE_PARENT_TABLE",
error, i);
if (tmp) {
hasfields = TRUE;
if (first) {
g_string_append (string, " INHERITS ");
first = FALSE;
}
else
g_string_append (string, ", ");
g_string_append (string, tmp);
g_free (tmp);
}
else {
g_string_free (string, TRUE);
return NULL;
}
}
}
if (!hasfields) {
g_string_free (string, TRUE);
g_set_error (error, GDA_SERVER_OPERATION_ERROR,
GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR,
"%s", _("Table to create must have at least one row"));
return NULL;
}
value = gda_server_operation_get_value_at (op, "/TABLE_DEF_P/TABLE_WITH_OIDS");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " WITH OIDS");
sql = string->str;
g_string_free (string, FALSE);
return sql;
}
static void create_and_fill_model ()
{
GtkTreeIter toplevel, child;
gint i;
GValue *date = ex_grid_get_selected_row_value (grid_account_full, ACF_TIME_T_COL);
GValue *account = ex_grid_get_selected_row_value (grid_account_full, ACF_ID_COL);
GValue *currency = ex_grid_get_selected_row_value (grid_account_full, ACF_CURRENCY_ID_COL);
// -- Expenditure
gchar *sql = "SELECT (SELECT name FROM category WHERE id=b.category_id), \
cast(amount*-1 as text)||(SELECT short_name FROM currency WHERE id=a.currency_id) \
FROM operation a, expin b \
WHERE a.id=b.id AND date=##date::gint AND account_id=##account::gint AND \
a.currency_id=##currency::gint AND amount < 0";
GdaDataModel *gda_model = db_exec_select_sql (sql,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model) > 0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel, NAME_COL, _("Expends"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, NAME_COL, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
g_object_unref(gda_model);
// -- Income
gchar *sql2 = "SELECT (SELECT name FROM category WHERE id=b.category_id), \
cast(amount as text)||(SELECT short_name FROM currency WHERE id=a.currency_id) \
FROM operation a, expin b \
WHERE a.id=b.id AND date=##date::gint AND account_id=##account::gint AND \
a.currency_id=##currency::gint AND amount > 0";
gda_model = db_exec_select_sql (sql2,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model) > 0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel, NAME_COL, _("Income"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, 0, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
g_object_unref(gda_model);
// -- Credits
gchar *sql_debt = "SELECT (SELECT name FROM person WHERE id=b.person_id),\
cast(a.amount as text)||(SELECT short_name FROM currency WHERE id=a.currency_id) \
FROM operation a, debtcredit b \
WHERE a.id=b.id AND a.date=##date::gint AND a.account_id=##account::gint AND \
a.currency_id=##currency::gint AND a.amount > 0";
gda_model = db_exec_select_sql (sql_debt,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model)>0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
NAME_COL,_("Credit"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, 0, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
g_object_unref(gda_model);
// -- Debts
gchar *sql_credit = "SELECT (SELECT name FROM person WHERE id=b.person_id),\
cast(a.amount*-1 as text)||(SELECT short_name FROM currency WHERE id=a.currency_id) \
FROM operation a, debtcredit b \
WHERE a.id=b.id AND a.date=##date::gint AND a.account_id=##account::gint AND \
a.currency_id=##currency::gint AND a.amount < 0";
gda_model = db_exec_select_sql (sql_credit,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model)>0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
NAME_COL,_("Debt"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, 0, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
g_object_unref(gda_model);
// -- Transfers
gchar *sql_transfer = "SELECT (SELECT name FROM account WHERE id=b.account_id)||' -> '||(SELECT name FROM account WHERE id=c.account_id), \
cast(c.amount as text)||(SELECT short_name FROM currency WHERE id=b.currency_id), b.description \
FROM transfer a, operation b, operation c \
WHERE a.expenditure_id=b.id AND a.income_id=c.id AND b.date=##date::gint \
AND (b.account_id=##account::gint OR c.account_id=##account::gint) AND b.currency_id=##currency::gint";
gda_model = db_exec_select_sql (sql_transfer,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model) > 0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
NAME_COL,_("Transfer"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, 0, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
g_object_unref(gda_model);
// -- Currency exchange
gchar *sql_exchange ="SELECT (SELECT name FROM account WHERE id=b.account_id),\
cast(b.amount*-1 as text)||(SELECT short_name FROM currency WHERE id=b.currency_id)||' -> '||cast(c.amount as text)||(SELECT short_name FROM currency WHERE id=c.currency_id), b.description \
FROM exchange a, operation b, operation c \
WHERE a.expenditure_id=b.id AND a.income_id=c.id AND b.date=##date::gint AND b.account_id=##account::gint AND \
(b.currency_id=##currency::gint OR c.currency_id=##currency::gint)";
gda_model = db_exec_select_sql (sql_exchange,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model) > 0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel,
NAME_COL,_("Currency Exchange"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, 0, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
g_object_unref(gda_model);
// -- Debt Payments
gchar *sql_debt_payment = "SELECT (SELECT name FROM person WHERE id=(SELECT person_id FROM debtcredit WHERE id=b.debtcredit_id)), \
cast(amount as text)||(SELECT short_name FROM currency WHERE id=a.currency_id) \
FROM operation a, debtcredit_payment b \
WHERE a.id=b.id AND date=##date::gint AND account_id=##account::gint AND \
a.currency_id=##currency::gint AND a.amount > 0";
gda_model = db_exec_select_sql (sql_debt_payment,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model) > 0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel, NAME_COL, _("Debt Payments"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, 0, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
g_object_unref(gda_model);
// -- Credit Payments
gchar *sql_credit_payment = "SELECT (SELECT name FROM person WHERE id=(SELECT person_id FROM debtcredit WHERE id=b.debtcredit_id)), \
cast(amount as text)||(SELECT short_name FROM currency WHERE id=a.currency_id) \
FROM operation a, debtcredit_payment b \
WHERE a.id=b.id AND date=##date::gint AND account_id=##account::gint AND \
a.currency_id=##currency::gint AND a.amount < 0";
gda_model = db_exec_select_sql (sql_credit_payment,
"date", date,
"account", account,
"currency", currency,
NULL);
if (gda_data_model_get_n_rows(gda_model) > 0)
{
gtk_tree_store_append(treestore, &toplevel, NULL);
gtk_tree_store_set(treestore, &toplevel, NAME_COL, _("Credit Payments"), -1);
for(i=0; i<gda_data_model_get_n_rows(gda_model); i++)
{
gtk_tree_store_append(treestore, &child, &toplevel);
gtk_tree_store_set_value(treestore, &child, NAME_COL, gda_data_model_get_value_at(gda_model, 0, i, NULL));
gtk_tree_store_set_value(treestore, &child, AMMOUNT_COL, gda_data_model_get_value_at(gda_model, AMMOUNT_COL, i, NULL));
}
}
gtk_tree_view_expand_all (treeview);
g_object_unref(gda_model);
}
static void
_midgard_query_select_execute (MidgardExecutable *iface, gboolean async, GError **error)
{
g_return_if_fail (iface != NULL);
MidgardQuerySelect *self = MIDGARD_QUERY_SELECT (iface);
MidgardQueryExecutor *executor = MIDGARD_QUERY_EXECUTOR (self);
GError *err = NULL;
midgard_validable_validate (MIDGARD_VALIDABLE (self), &err);
if (err) {
g_propagate_error (error, err);
return;
}
MidgardDBObjectClass *klass = executor->priv->storage->priv->klass;
MidgardConnection *mgd = executor->priv->mgd;
GdaConnection *cnc = mgd->priv->connection;
GdaSqlStatement *sql_stm;
GdaSqlStatementSelect *sss;
sql_stm = gda_sql_statement_new (GDA_SQL_STATEMENT_SELECT);
sss = (GdaSqlStatementSelect*) sql_stm->contents;
g_assert (GDA_SQL_ANY_PART (sss)->type == GDA_SQL_ANY_STMT_SELECT);
MIDGARD_QUERY_EXECUTOR (self)->priv->stmt = sql_stm;
sss->from = gda_sql_select_from_new (GDA_SQL_ANY_PART (sss));
/* Initialize top base expresion and operation with default AND operator type */
GdaSqlExpr *base_where = gda_sql_expr_new (GDA_SQL_ANY_PART (sss));
GdaSqlOperation *base_operation = gda_sql_operation_new (GDA_SQL_ANY_PART (base_where));
base_operation->operator_type = GDA_SQL_OPERATOR_TYPE_AND;
base_where->cond = base_operation;
gda_sql_statement_select_take_where_cond (sql_stm, base_where);
/* Create targets (FROM) */
GdaSqlSelectTarget *s_target = gda_sql_select_target_new (GDA_SQL_ANY_PART (sss->from));
s_target->table_name = g_strdup (midgard_core_class_get_table (klass));
s_target->as = g_strdup_printf ("t%d", ++MIDGARD_QUERY_EXECUTOR (self)->priv->tableid);
MIDGARD_QUERY_EXECUTOR (self)->priv->table_alias = g_strdup (s_target->as);
gda_sql_select_from_take_new_target (sss->from, s_target);
/* Set target expression */
GdaSqlExpr *texpr = gda_sql_expr_new (GDA_SQL_ANY_PART (s_target));
GValue *tval = g_new0 (GValue, 1);
g_value_init (tval, G_TYPE_STRING);
g_value_set_string (tval, s_target->table_name);
texpr->value = tval;
s_target->expr = texpr;
/* Add fields for all properties registered per class (SELECT a,b,c...) */
klass->dbpriv->add_fields_to_select_statement (klass, mgd, sss, s_target->as);
GdaSqlExpr *where = sss->where_cond;
GdaSqlOperation *operation = where->cond;
/* Add joins, LEFT JOIN tbl2 ON... */
__query_select_add_joins (MIDGARD_QUERY_SELECT (self), operation, &err);
if (err) {
g_propagate_error (error, err);
goto return_false;
}
/* Add constraints' conditions (WHERE a=1, b=2...) */
if (MIDGARD_QUERY_EXECUTOR (self)->priv->constraint) {
MIDGARD_QUERY_CONSTRAINT_SIMPLE_GET_INTERFACE (MIDGARD_QUERY_EXECUTOR (self)->priv->constraint)->priv->add_conditions_to_statement (MIDGARD_QUERY_EXECUTOR (self), MIDGARD_QUERY_EXECUTOR (self)->priv->constraint, sql_stm, base_where, &err);
if (err) {
g_propagate_error (error, err);
goto return_false;
}
if (MIDGARD_QUERY_EXECUTOR (self)->priv->n_constraints == 1)
__add_second_dummy_constraint (sss, operation);
/* Add dummy constraint if operation has only one operand */
if (operation->operands && (g_slist_length (operation->operands) == 1))
__add_dummy_constraint (sss, operation);
} else {
/* no constraints, add dummy '1=1 AND 0<1' to satisfy top constraint group */
__add_dummy_constraint (sss, operation);
__add_second_dummy_constraint (sss, operation);
}
/* Add orders , ORDER BY t1.field... */
if (!__query_select_add_orders (executor, &err)) {
if (err)
g_propagate_error (error, err);
goto return_false;
}
/* Exclude deleted */
if (MGD_DBCLASS_METADATA_CLASS (klass) && !executor->priv->include_deleted)
__add_exclude_deleted_constraints (executor, sss, operation, klass);
/* Add limit, LIMIT x */
if (executor->priv->limit > 0) {
GdaSqlExpr *limit_expr = gda_sql_expr_new (GDA_SQL_ANY_PART (sss));
GValue *limit_val = g_new0 (GValue, 1);
g_value_init (limit_val, G_TYPE_STRING);
g_value_take_string (limit_val, g_strdup_printf ("%d", executor->priv->limit));
limit_expr->value = limit_val;
sss->limit_count = limit_expr;
}
/* Add offset, OFFSET x */
if (executor->priv->offset >= 0) {
GdaSqlExpr *offset_expr = gda_sql_expr_new (GDA_SQL_ANY_PART (sss));
GValue *offset_val = g_new0 (GValue, 1);
g_value_init (offset_val, G_TYPE_STRING);
g_value_take_string (offset_val, g_strdup_printf ("%d", executor->priv->offset));
offset_expr->value = offset_val;
sss->limit_offset = offset_expr;
}
/* Check structure */
if (!gda_sql_statement_check_structure (sql_stm, &err)) {
g_set_error (error, MIDGARD_EXECUTION_ERROR, MIDGARD_EXECUTION_ERROR_INTERNAL,
"Can't build SELECT statement: %s)", err && err->message ? err->message : _("Unknown reason"));
if (err)
g_clear_error (&err);
goto return_false;
}
/* Create statement */
GdaStatement *stmt = gda_statement_new ();
g_object_set (G_OBJECT (stmt), "structure", sql_stm, NULL);
gda_sql_statement_free (sql_stm);
sql_stm = NULL;
if (MGD_CNC_DEBUG (mgd)) {
gchar *debug_sql = gda_connection_statement_to_sql (cnc, stmt, NULL, GDA_STATEMENT_SQL_PRETTY, NULL, NULL);
g_debug ("QuerySelect: %s", debug_sql);
g_free (debug_sql);
}
/* execute statement */
GdaDataModel *model = NULL;
midgard_executable_execution_start (MIDGARD_EXECUTABLE(self));
model = gda_connection_statement_execute_select (cnc, stmt, NULL, &err);
g_object_unref (stmt);
if (!model && !err) {
g_set_error (error, MIDGARD_EXECUTION_ERROR, MIDGARD_EXECUTION_ERROR_INTERNAL,
"Execute error - Unknown reason, underlying error is NULL");
goto return_false;
}
if (err) {
g_set_error (error, MIDGARD_EXECUTION_ERROR, MIDGARD_EXECUTION_ERROR_INTERNAL,
"Execute error - %s", err->message);
g_error_free (err);
goto return_false;
}
executor->priv->results_count = gda_data_model_get_n_rows (model);
if (executor->priv->resultset && G_IS_OBJECT (executor->priv->resultset))
g_object_unref (G_OBJECT (executor->priv->resultset));
executor->priv->resultset = (gpointer) model;
return;
return_false:
if (sql_stm)
gda_sql_statement_free (sql_stm);
return;
}
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);
}
}
/**
* Display a list with projects and let the user select one. Returns the project
* id of the selected one.
*/
static gint
sql_plugin_retrieve_project_id (PlannerPlugin *plugin,
gchar *server,
gchar *port,
gchar *database,
gchar *login,
gchar *password)
{
GdaConnection *conn;
GdaDataModel *model;
gboolean success;
GdaClient *client;
GladeXML *gui;
GtkWidget *dialog;
GtkWidget *treeview;
GtkWidget *ok_button;
GtkListStore *liststore;
GtkCellRenderer *cell;
GtkTreeViewColumn *col;
gint i;
gint response;
gint project_id;
GtkTreeSelection *selection;
GtkTreeIter iter;
gchar *db_txt;
const gchar *dsn_name = "planner-auto";
const gchar *provider = "PostgreSQL";
gchar *filename;
db_txt = g_strdup_printf (CONNECTION_FORMAT_STRING,server,database);
gda_config_save_data_source (dsn_name,
provider,
db_txt,
"planner project", login, password, FALSE);
g_free (db_txt);
client = gda_client_new ();
conn = sql_get_tested_connection (dsn_name, server, database, client, plugin);
if (conn == NULL) {
return -1;
}
success = sql_execute_command (conn, "BEGIN");
if (!success) {
g_warning ("BEGIN command failed.");
return -1;
}
success = sql_execute_command (conn,
"DECLARE mycursor CURSOR FOR SELECT proj_id, name,"
"phase, revision FROM project ORDER by proj_id ASC");
if (!success) {
g_warning ("DECLARE CURSOR command failed (project).");
return -1;
}
model = sql_execute_query (conn, "FETCH ALL in mycursor");
if (model == NULL) {
g_warning ("FETCH ALL failed.");
return -1;
}
filename = mrp_paths_get_glade_dir ("sql.glade");
gui = glade_xml_new (filename, "select_dialog", NULL);
g_free (filename);
dialog = glade_xml_get_widget (gui, "select_dialog");
treeview = glade_xml_get_widget (gui, "project_treeview");
ok_button = glade_xml_get_widget (gui, "ok_button");
g_object_unref (gui);
liststore = gtk_list_store_new (4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT);
gtk_tree_view_set_model (GTK_TREE_VIEW (treeview), GTK_TREE_MODEL (liststore));
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("ID"),
cell,
"text", COL_ID,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Project"),
cell,
"text", COL_NAME,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Phase"),
cell,
"text", COL_PHASE,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
cell = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes (_("Revision"),
cell,
"text", COL_REVISION,
NULL);
gtk_tree_view_column_set_resizable (col, TRUE);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), col);
gtk_tree_view_columns_autosize (GTK_TREE_VIEW (treeview));
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection,
"changed",
G_CALLBACK (selection_changed_cb),
ok_button);
g_signal_connect (treeview,
"row_activated",
G_CALLBACK (row_activated_cb),
ok_button);
for (i = 0; i < gda_data_model_get_n_rows (model); i++) {
gint id;
gchar *name;
gchar *phase;
gint revision;
id = get_int (model, i, 0);
name = get_string (model, i, 1);
phase = get_string (model, i, 2);
revision = get_int (model, i, 3);
/* FIXME: needs fixing in the database backend. */
if (strcmp (phase, "NULL") == 0) {
g_free (phase);
phase = g_strdup ("");
}
gtk_list_store_append (GTK_LIST_STORE (liststore), &iter);
gtk_list_store_set (GTK_LIST_STORE (liststore),
&iter,
COL_ID, id,
COL_NAME, name,
COL_PHASE, phase,
COL_REVISION, revision,
-1);
g_free (name);
g_free (phase);
}
if (gda_data_model_get_n_columns (model) == 0) {
gtk_widget_set_sensitive (ok_button, FALSE);
}
g_object_unref (model);
sql_execute_command (conn,"CLOSE mycursor");
gtk_widget_show_all (dialog);
response = gtk_dialog_run (GTK_DIALOG (dialog));
project_id = -1;
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
break;
case GTK_RESPONSE_OK:
if (!gtk_tree_selection_get_selected (selection, NULL, &iter)) {
break;
}
gtk_tree_model_get (GTK_TREE_MODEL (liststore),
&iter,
COL_ID, &project_id,
-1);
break;
};
gtk_widget_destroy (dialog);
return project_id;
}
gchar *
gda_postgres_render_CREATE_VIEW (GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, G_GNUC_UNUSED GError **error)
{
GString *string;
const GValue *value;
gchar *sql = NULL;
gchar *tmp;
string = g_string_new ("CREATE ");
value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_OR_REPLACE");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "OR REPLACE ");
value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_TEMP");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "TEMP ");
g_string_append (string, "VIEW ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/VIEW_DEF_P/VIEW_NAME", error);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
GdaServerOperationNode *node;
node = gda_server_operation_get_node_info (op, "/FIELDS_A");
if (node) {
gint i, nrows;
GString *cols = NULL;
nrows = gda_data_model_get_n_rows (node->model);
for (i = 0; i < nrows; i++) {
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FIELDS_A/@COLUMN_NAME/%d",
error, i);
if (!tmp) {
g_string_free (string, TRUE);
return NULL;
}
if (cols)
g_string_append (cols, ", ");
g_string_append (cols, tmp);
g_string_append_c (cols, ' ');
g_free (tmp);
}
if (cols) {
g_string_append_c (cols, ')');
g_string_append (string, cols->str);
g_string_free (cols, TRUE);
}
}
value = gda_server_operation_get_value_at (op, "/VIEW_DEF_P/VIEW_DEF");
g_assert (value && G_VALUE_HOLDS (value, G_TYPE_STRING));
g_string_append (string, " AS ");
g_string_append (string, g_value_get_string (value));
sql = string->str;
g_string_free (string, FALSE);
return sql;
}
/*
* evaluate_expression
*
* Evaluates the @expr expression, which must be a valid SQLite expression
*
* Returns: a new GValue if no error occurred
*/
static GValue *
evaluate_expression (GdaReportEngine *engine, RunContext *context, const gchar *expr, GError **error)
{
GdaStatement *stmt;
GdaSet *plist;
GdaDataModel *model;
GValue *retval;
gchar *sql;
static GMutex init_mutex;
GdaConnection *vcnc = NULL;
GdaSqlParser *parser;
/* create a virtual connection to execute the expression, if it's the first time */
g_mutex_lock (&init_mutex);
if (!vcnc) {
static GdaVirtualProvider *provider = NULL;
if (!provider)
provider = gda_vprovider_data_model_new ();
vcnc = gda_virtual_connection_open (provider, GDA_CONNECTION_OPTIONS_NONE, error);
if (! vcnc) {
g_mutex_unlock (&init_mutex);
return NULL;
}
}
g_mutex_unlock (&init_mutex);
/* parser */
parser = g_object_get_data (G_OBJECT (context->cnc), "__gda_parser");
if (!parser) {
parser = gda_connection_create_parser (context->cnc);
g_object_set_data_full (G_OBJECT (context->cnc), "__gda_parser",
parser, g_object_unref);
}
/* create the stmt
* REM: SQL injection is prevented because only the first statement is kept by GdaStatement
*/
sql = g_strdup_printf ("SELECT %s", expr);
stmt = gda_sql_parser_parse_string (parser, sql, NULL, error);
if (!stmt)
return NULL;
GdaStatement *lstmt;
lstmt = rewrite_statement (engine, context, stmt, error);
g_object_unref (stmt);
if (!lstmt)
return NULL;
stmt = lstmt;
if (!gda_statement_get_parameters (stmt, &plist, error)) {
g_object_unref (stmt);
return NULL;
}
if (plist) {
if (!assign_parameters_values (engine, context, plist, error)) {
g_object_unref (stmt);
g_object_unref (plist);
return NULL;
}
}
model = gda_connection_statement_execute_select (vcnc, stmt, plist, error);
if (plist)
g_object_unref (plist);
g_object_unref (stmt);
if (!model)
return NULL;
if (gda_data_model_get_n_rows (model) != 1) {
g_set_error (error, 0, 0,
_("Expression '%s' should return exactly one value"), expr);
return NULL;
}
retval = (GValue *) gda_data_model_get_value_at (model, 0, 0, error);
if (retval)
retval = gda_value_copy (retval);
g_object_unref (model);
return retval;
}
void
_gda_postgres_compute_types (GdaConnection *cnc, GdaPostgresReuseable *rdata)
{
if (rdata->types_oid_hash)
return;
rdata->types_oid_hash = g_hash_table_new_full (g_int_hash, g_int_equal,
NULL, (GDestroyNotify) gda_postgres_type_oid_free);
rdata->types_dbtype_hash = g_hash_table_new (g_str_hash, g_str_equal);
GdaDataModel *model, *model_avoid, *model_anyoid = NULL;
gint ncols, nrows, i;
gchar *avoid_types = NULL;
GString *string;
if (rdata->version_float == 0)
_gda_postgres_compute_version (cnc, rdata, NULL);
if (rdata->version_float < 7.3) {
gchar *query;
avoid_types = "'SET', 'cid', 'oid', 'int2vector', 'oidvector', 'regproc', 'smgr', 'tid', 'unknown', 'xid'";
/* main query to fetch infos about the data types */
query = g_strdup_printf ("SELECT pg_type.oid, typname, usename, obj_description(pg_type.oid) "
"FROM pg_type, pg_user "
"WHERE typowner=usesysid AND typrelid = 0 AND typname !~ '^_' "
"AND typname not in (%s) "
"ORDER BY typname", avoid_types);
model = execute_select (cnc, rdata, query);
g_free (query);
/* query to fetch non returned data types */
query = g_strdup_printf ("SELECT pg_type.oid FROM pg_type WHERE typname in (%s)", avoid_types);
model_avoid = execute_select (cnc, rdata, query);
g_free (query);
}
else {
gchar *query;
avoid_types = "'any', 'anyarray', 'anyelement', 'cid', 'cstring', 'int2vector', 'internal', 'language_handler', 'oidvector', 'opaque', 'record', 'refcursor', 'regclass', 'regoper', 'regoperator', 'regproc', 'regprocedure', 'regtype', 'SET', 'smgr', 'tid', 'trigger', 'unknown', 'void', 'xid'";
/* main query to fetch infos about the data types */
query = g_strdup_printf (
"SELECT t.oid, t.typname, u.usename, pg_catalog.obj_description(t.oid), t.typinput "
"FROM pg_catalog.pg_type t LEFT JOIN pg_catalog.pg_user u ON (t.typowner=u.usesysid), pg_catalog.pg_namespace n "
"WHERE n.oid = t.typnamespace "
"AND pg_catalog.pg_type_is_visible(t.oid) "
/*--AND (n.nspname = 'public' OR n.nspname = 'pg_catalog')*/
"AND typname !~ '^_' "
"AND (t.typrelid = 0 OR "
"(SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid)) "
"AND t.typname not in (%s) "
"ORDER BY typname", avoid_types);
model = execute_select (cnc, rdata, query);
g_free (query);
/* query to fetch non returned data types */
query = g_strdup_printf ("SELECT t.oid FROM pg_catalog.pg_type t WHERE t.typname in (%s)",
avoid_types);
model_avoid = execute_select (cnc, rdata, query);
g_free (query);
/* query to fetch the oid of the 'any' data type */
model_anyoid = execute_select (cnc, rdata,
"SELECT t.oid FROM pg_catalog.pg_type t WHERE t.typname = 'any'");
}
if (rdata->version_float == 0)
_gda_postgres_compute_version (cnc, rdata, NULL);
if (!model || !model_avoid ||
((rdata->version_float >= 7.3) && !model_anyoid)) {
if (model)
g_object_unref (model);
if (model_avoid)
g_object_unref (model_avoid);
if (model_anyoid)
g_object_unref (model_anyoid);
return;
}
/* Data types returned to the Gda client */
nrows = gda_data_model_get_n_rows (model);
ncols = gda_data_model_get_n_columns (model);
if (nrows == 0)
g_warning ("PostgreSQL provider did not find any data type (expect some mis-behaviours) please report the error to bugzilla.gnome.org");
for (i = 0; i < nrows; i++) {
const GValue *conv_func_name = NULL;
const GValue *values[4];
gint j;
gboolean allread = TRUE;
if (ncols >= 5)
conv_func_name = gda_data_model_get_value_at (model, 4, i, NULL);
for (j = 0; j < 4; j++) {
values[j] = gda_data_model_get_value_at (model, j, i, NULL);
if (!values [j]) {
allread = FALSE;
break;
}
}
if (allread && (G_VALUE_TYPE (values[1]) == G_TYPE_STRING)) {
GdaPostgresTypeOid *td;
td = g_new0 (GdaPostgresTypeOid, 1);
td->name = g_value_dup_string (values [1]);
td->oid = (guint) g_ascii_strtoull (g_value_get_string (values[0]), NULL, 10);
td->type = postgres_name_to_g_type (td->name,
conv_func_name ? g_value_get_string (conv_func_name) : NULL);
if (G_VALUE_TYPE (values[3]) == G_TYPE_STRING)
td->comments = g_value_dup_string (values [3]);
if (G_VALUE_TYPE (values[2]) == G_TYPE_STRING)
td->owner = g_value_dup_string (values [2]);
g_hash_table_insert (rdata->types_oid_hash, &(td->oid), td);
g_hash_table_insert (rdata->types_dbtype_hash, &(td->name), td);
}
}
/* Make a string of data types internal to postgres and not returned, for future queries */
string = NULL;
nrows = gda_data_model_get_n_rows (model_avoid);
for (i = 0; i < nrows; i++) {
const GValue *cvalue;
cvalue = gda_data_model_get_value_at (model_avoid, 0, i, NULL);
if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING)) {
if (!string)
string = g_string_new (g_value_get_string (cvalue));
else {
g_string_append (string, ", ");
g_string_append (string, g_value_get_string (cvalue));
}
}
}
rdata->avoid_types = avoid_types;
if (string)
rdata->avoid_types_oids = g_string_free (string, FALSE);
g_object_unref (model);
g_object_unref (model_avoid);
/* make a string of the oid of type 'any' */
rdata->any_type_oid = NULL;
if (model_anyoid) {
if (gda_data_model_get_n_rows (model_anyoid) == 1) {
const GValue *cvalue;
cvalue = gda_data_model_get_value_at (model_anyoid, 0, 0, NULL);
if (cvalue && (G_VALUE_TYPE (cvalue) == G_TYPE_STRING))
rdata->any_type_oid = g_value_dup_string (cvalue);
}
g_object_unref (model_anyoid);
}
}
/**
* midgard_replicator_export_purged:
* @mgd: #MidgardConnection instance
* @classname: name of #MidgardObjectClass derived one
* @startdate: optional start date
* @enddate: optional end date
*
* Exports all purged objects of given class. If @startdate or @enddate are not NULL,
* all objects which were purged between dates will be exported.
*
* Returns: xml buffer with serialized objects or %NULL if there are no objects matching given criteria.
*/
gchar *
midgard_replicator_export_purged (MidgardConnection *mgd, const gchar *classname, const gchar *startdate, const gchar *enddate)
{
g_return_val_if_fail (mgd != NULL, NULL);
g_return_val_if_fail (classname != NULL, NULL);
MidgardDBObjectClass *klass = g_type_class_peek (g_type_from_name (classname));
g_return_val_if_fail (klass != NULL, NULL);
MIDGARD_ERRNO_SET(mgd, MGD_ERR_OK);
GString *sql = g_string_new(" SELECT guid, object_action_date ");
g_string_append_printf(sql, " FROM repligard where typename = '%s' "
" AND object_action = %d",
G_OBJECT_CLASS_NAME(klass),
MGD_OBJECT_ACTION_PURGE);
if(startdate != NULL){
g_string_append_printf(sql, " AND object_action_date > '%s' ",
startdate);
}
if(enddate != NULL) {
g_string_append_printf(sql, " AND object_action_date < '%s' ",
enddate);
}
GdaDataModel *model =
midgard_core_query_get_model(mgd, sql->str);
guint rows = gda_data_model_get_n_rows(model);
g_string_free(sql, TRUE);
if(!model)
return NULL;
if(rows == 0) {
if(model) g_object_unref(model);
return NULL;
}
xmlNode *object_node;
xmlDoc *doc =
midgard_core_object_create_xml_doc();
xmlNode *root_node =
xmlDocGetRootElement(doc);
guint i;
for(i = 0; i < rows; i++) {
gboolean free_converted = FALSE;
const gchar *purged = NULL;
GValue strv = {0, };
const GValue *value =
midgard_data_model_get_value_at(model, 0, i);
const gchar *guid = g_value_get_string(value);
value = midgard_data_model_get_value_at(model, 1, i);
if(G_IS_VALUE(value) && G_VALUE_TYPE(value) == GDA_TYPE_TIMESTAMP) {
g_value_init(&strv, G_TYPE_STRING);
free_converted = TRUE;
if(g_value_transform((const GValue *)value, &strv))
purged = g_value_get_string(&strv);
} else {
purged = g_value_get_string(value);
}
object_node = xmlNewNode(NULL, BAD_CAST G_OBJECT_CLASS_NAME(klass));
xmlNewProp(object_node, BAD_CAST "purge", BAD_CAST "yes");
xmlNewProp(object_node, BAD_CAST "guid", BAD_CAST guid);
xmlNewProp(object_node, BAD_CAST "purged", BAD_CAST purged);
xmlAddChild(root_node, object_node);
if(free_converted)
g_value_unset(&strv);
}
g_object_unref(model);
xmlChar *buf;
gint size;
xmlDocDumpFormatMemoryEnc(doc, &buf, &size, "UTF-8", 1);
xmlFreeDoc(doc);
xmlCleanupParser();
return (gchar*) buf;
}
/*
* render SQL
*/
static gboolean
test2 (GError **error)
{
GdaSqlParser *parser = NULL;
GHashTable *parsers_hash;
GdaDataModel *providers_model;
gint i;
/* create parsers */
parsers_hash = g_hash_table_new (g_str_hash, g_str_equal);
providers_model = gda_config_list_providers ();
for (i = 0; i < gda_data_model_get_n_rows (providers_model); i++) {
const GValue *pname;
pname = gda_data_model_get_value_at (providers_model, 0, i, error);
if (!pname)
return FALSE;
parser = create_parser_for_provider (g_value_get_string (pname));
g_hash_table_insert (parsers_hash, g_strdup (g_value_get_string (pname)), parser);
g_print ("Created parser for provider %s\n", g_value_get_string (pname));
}
g_object_unref (providers_model);
g_hash_table_insert (parsers_hash, "", gda_sql_parser_new ());
xmlDocPtr doc;
xmlNodePtr root, node;
gchar *fname;
fname = g_build_filename (ROOT_DIR, "tests", "parser", "testdata.xml", NULL);
if (! g_file_test (fname, G_FILE_TEST_EXISTS)) {
g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC, "File '%s' does not exist\n", fname);
return FALSE;
}
doc = xmlParseFile (fname);
g_free (fname);
g_assert (doc);
root = xmlDocGetRootElement (doc);
g_assert (!strcmp ((gchar*) root->name, "testdata"));
for (node = root->children; node; node = node->next) {
if (strcmp ((gchar*) node->name, "test"))
continue;
xmlNodePtr snode;
xmlChar *sql = NULL;
xmlChar *id;
xmlChar *prov_name;
prov_name = xmlGetProp (node, BAD_CAST "provider");
if (prov_name) {
parser = g_hash_table_lookup (parsers_hash, (gchar *) prov_name);
xmlFree (prov_name);
}
else
parser = g_hash_table_lookup (parsers_hash, "");
if (!parser)
continue;
for (snode = node->children; snode && strcmp ((gchar*) snode->name, "sql"); snode = snode->next);
if (!snode)
continue;
sql = xmlNodeGetContent (snode);
if (!sql)
continue;
GdaStatement *stmt;
GError *lerror = NULL;
stmt = gda_sql_parser_parse_string (parser, sql, NULL, &lerror);
xmlFree (sql);
id = xmlGetProp (node, BAD_CAST "id");
g_print ("===== TEST %s\n", id);
if (!stmt) {
/* skip that SQL if it can't be parsed */
g_error_free (lerror);
continue;
}
else {
GdaStatement *stmt2;
gchar *rsql;
gchar *ser1, *ser2;
rsql = gda_statement_to_sql_extended (stmt, NULL, NULL, 0, NULL, &lerror);
if (!rsql) {
g_print ("REM: test '%s' can't be rendered: %s\n", id,
lerror && lerror->message ? lerror->message : "No detail");
xmlFree (id);
continue;
}
/*g_print ("--> rendered SQL: %s\n", rsql);*/
stmt2 = gda_sql_parser_parse_string (parser, rsql, NULL, error);
if (!stmt2)
return FALSE;
GdaSqlStatement *sqlst;
g_object_get (G_OBJECT (stmt), "structure", &sqlst, NULL);
g_free (sqlst->sql);
sqlst->sql = NULL;
ser1 = gda_sql_statement_serialize (sqlst);
gda_sql_statement_free (sqlst);
g_object_get (G_OBJECT (stmt2), "structure", &sqlst, NULL);
g_free (sqlst->sql);
sqlst->sql = NULL;
ser2 = gda_sql_statement_serialize (sqlst);
gda_sql_statement_free (sqlst);
if (strcmp (ser1, ser2)) {
g_set_error (error, TEST_ERROR, TEST_ERROR_GENERIC,
"Statement failed, ID: %s\nSQL: %s\nSER1: %s\nSER2 :%s",
id, rsql, ser1, ser2);
g_free (ser1);
g_free (ser2);
return FALSE;
}
g_free (rsql);
g_free (ser1);
g_free (ser2);
g_object_unref (stmt);
g_object_unref (stmt2);
}
xmlFree (id);
if (lerror)
g_error_free (lerror);
}
g_object_unref (parser);
return TRUE;
}
int
main (int argc, char *argv[])
{
GOptionContext *context;
GError *error = NULL;
int exit_status = EXIT_SUCCESS;
GSList *list, *cnc_list = NULL;
context = g_option_context_new ("[DSN|connection string]...");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_print ("Can't parse arguments: %s\n", error->message);
exit_status = EXIT_FAILURE;
goto cleanup;
}
g_option_context_free (context);
gda_init ();
ask_pass = !ask_pass;
config = g_new0 (HtmlConfig, 1);
html_init_config (HTML_CONFIG (config));
config->index = html_file_new (HTML_CONFIG (config),
"index.html", "Providers status");
config->dir = g_strdup (".");
/* parse command line arguments for connections */
if (argc > 1) {
gint i;
for (i = 1; i < argc; i++) {
/* open connection */
GdaConnection *cnc;
cnc = open_connection (argv[i], &error);
if (!cnc) {
g_print ("Can't open connection to '%s': %s\n", argv[i],
error && error->message ? error->message : "No detail");
exit_status = EXIT_FAILURE;
goto cleanup;
}
cnc_list = g_slist_append (cnc_list, cnc);
}
}
else {
if (getenv ("GDA_SQL_CNC")) {
GdaConnection *cnc;
cnc = open_connection (getenv ("GDA_SQL_CNC"), &error);
if (!cnc) {
g_print ("Can't open connection defined by GDA_SQL_CNC: %s\n",
error && error->message ? error->message : "No detail");
exit_status = EXIT_FAILURE;
goto cleanup;
}
cnc_list = g_slist_append (cnc_list, cnc);
}
else {
/* report status for all providers */
GdaDataModel *providers;
gint i, nb;
providers = gda_config_list_providers ();
nb = gda_data_model_get_n_rows (providers);
for (i = 0; i < nb; i++) {
GdaServerProvider *prov = NULL;
const gchar *pname;
const GValue *cvalue;
cvalue = gda_data_model_get_value_at (providers, 0, i, &error);
if (!cvalue)
g_error ("Can't load next provider: %s\n",
error && error->message ? error->message : "No detail");
pname = g_value_get_string (cvalue);
prov = gda_config_get_provider (pname, &error);
if (!prov)
g_error ("Can't load the '%s' provider: %s\n", pname,
error && error->message ? error->message : "No detail");
if (!report_provider_status (prov, NULL)) {
exit_status = EXIT_FAILURE;
goto cleanup;
}
}
g_object_unref (providers);
}
}
/* report provider's status for all the connections */
for (list = cnc_list; list; list = list->next) {
if (!report_provider_status (NULL, GDA_CONNECTION (list->data))) {
exit_status = EXIT_FAILURE;
goto cleanup;
}
}
g_slist_foreach (HTML_CONFIG (config)->all_files, (GFunc) html_file_write, config);
/* cleanups */
cleanup:
g_slist_foreach (cnc_list, (GFunc) g_object_unref, NULL);
g_slist_free (cnc_list);
return exit_status;
}
GList *
midgard_core_qb_set_object_from_query (MidgardQueryBuilder *builder, guint select_type, MidgardObject **nobject)
{
g_assert(builder != NULL);
guint ret_rows, ret_fields;
MidgardConnection *mgd = builder->priv->mgd;
gchar *sql = midgard_core_qb_get_sql(
builder, select_type,
midgard_query_builder_get_object_select(builder, select_type));
GSList *olist = NULL;
MidgardDBObjectClass *dbklass = MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type));
if (!dbklass) {
MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_INTERNAL, "Failed to peek MidgardDBObjectClass pointer");
return NULL;
}
if (dbklass->dbpriv->set_from_sql) {
if (select_type != MQB_SELECT_GUID) {
olist = dbklass->dbpriv->set_from_sql(mgd, builder->priv->type, ((const gchar *)sql));
g_free(sql);
return (GList *)olist;
}
}
GdaDataModel *model = midgard_core_query_get_model(builder->priv->mgd, sql);
g_free(sql);
if(!model)
return NULL;
MidgardObject *object = NULL;
gint rows, columns;
const GValue *gvalue = NULL;
ret_rows = gda_data_model_get_n_rows(model);
ret_fields = gda_data_model_get_n_columns(model);
/* records found , allocate as many objects as many returned rows */
GList *list = NULL;
if(ret_rows == 0) {
g_object_unref(model);
return list;
}
/* We count rows only */
if(select_type == MQB_SELECT_GUID) {
gvalue = midgard_data_model_get_value_at(model, 0, 0);
if (!gvalue || !G_IS_VALUE (gvalue)) {
g_object_unref (model);
return 0;
}
MidgardTypeHolder *holder = g_new(MidgardTypeHolder, 1);
GValue val = {0, };
g_value_init (&val, G_TYPE_INT64);
g_value_transform (gvalue, &val);
holder->elements = (guint)g_value_get_int64((GValue*)&val);
list = g_list_append(list, holder);
g_object_unref(model);
g_value_unset (&val);
return list;
}
/* Get every row */
for (rows = 0; rows < ret_rows; rows++) {
if(!nobject)
object = g_object_new (builder->priv->type, "connection", mgd, NULL);
else
object = *nobject;
MGD_OBJECT_IN_STORAGE (object) = TRUE;
if(dbklass->dbpriv->__set_from_sql != NULL) {
dbklass->dbpriv->__set_from_sql(MIDGARD_DBOBJECT(object),
model, rows);
} else {
/* Compute number of metadata properties */
guint n_md_props = 0;
MidgardMetadata *mklass = (MidgardMetadata *)MGD_DBCLASS_METADATA_CLASS (dbklass);
if (mklass)
n_md_props = g_hash_table_size (MGD_DBCLASS_STORAGE_DATA (mklass)->prophash);
guint __cols = n_md_props + 1; /* Add one for guid */
/* we have guid and metadata columns first */
for (columns = __cols; columns < ret_fields; columns++) {
gvalue = midgard_data_model_get_value_at(model, columns, rows);
const gchar *coltitle =
gda_data_model_get_column_title(model, columns);
GParamSpec *pspec =
g_object_class_find_property(G_OBJECT_GET_CLASS(object), coltitle);
if(G_IS_VALUE(gvalue)) {
if (!pspec) {
g_warning("Failed to found (unregistered) %s property (%s class)",
coltitle, G_OBJECT_TYPE_NAME(object));
continue;
}
if (G_VALUE_TYPE (gvalue) == GDA_TYPE_BINARY
&& G_TYPE_FUNDAMENTAL (pspec->value_type) == G_TYPE_STRING) {
gchar *stringified = midgard_core_query_binary_stringify ((GValue *)gvalue);
g_object_set (G_OBJECT (object), coltitle, stringified, NULL);
g_free (stringified);
} else if (pspec->value_type != G_VALUE_TYPE (gvalue)) {
GValue _convert = {0, };
g_value_init (&_convert, pspec->value_type);
if (g_value_transform (gvalue, &_convert)) {
/* FIXME, remove workaround once it's fixed in GDA */
/* https://bugzilla.gnome.org/show_bug.cgi?id=617550 */
guint dbtype = mgd->priv->config->priv->dbtype;
if (dbtype == MIDGARD_DB_TYPE_MYSQL && G_VALUE_TYPE (gvalue) == GDA_TYPE_BLOB) {
gchar *tmp_str = __default_unescape_string (g_value_get_string (&_convert));
if (tmp_str)
g_value_take_string (&_convert, tmp_str);
}
g_object_set_property (G_OBJECT (object), coltitle, &_convert);
} else {
g_warning ("Failed to convert %s to %s for %s property",
G_VALUE_TYPE_NAME (gvalue),
G_VALUE_TYPE_NAME (&_convert),
coltitle);
}
g_value_unset (&_convert);
} else {
g_object_set_property(G_OBJECT(object), coltitle, gvalue);
}
} else if (gda_value_is_null(gvalue)) {
switch (pspec->value_type) {
case G_TYPE_INT:
case G_TYPE_UINT:
g_object_set(G_OBJECT(object), coltitle, 0, NULL);
break;
case G_TYPE_STRING:
g_object_set(G_OBJECT(object), coltitle, "", NULL);
break;
default:
g_warning("Found (%s) not a value at %d.%d (%s)",
g_type_name(pspec->value_type),
columns, rows,
gda_data_model_get_column_title(model, columns));
break;
}
}
}
}
/* Set guid */
const gchar *guid;
gvalue = midgard_data_model_get_value_at(model, 0, rows);
if(G_IS_VALUE(gvalue) && G_VALUE_HOLDS_STRING(gvalue)){
guid = g_value_get_string(gvalue);
g_free((gchar *)MIDGARD_DBOBJECT(object)->dbpriv->guid);
MIDGARD_DBOBJECT(object)->dbpriv->guid = g_strdup(guid);
}
/* Set metadata */
MidgardMetadata *metadata = MGD_DBOBJECT_METADATA (object);
if (metadata) {
GParamSpec *pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object), "metadata");
if (pspec)
__mqb_set_metadata(metadata, model, rows);
}
list = g_list_append(list, G_OBJECT(object));
}
g_object_unref(model);
return list;
}
gchar *
_gda_sqlite_render_CREATE_TABLE (GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, GError **error)
{
g_return_val_if_fail (provider, NULL);
g_return_val_if_fail (cnc, NULL);
g_return_val_if_fail (op, NULL);
g_return_val_if_fail (gda_server_operation_get_op_type (op) == GDA_SERVER_OPERATION_CREATE_TABLE, NULL);
GString *string;
const GValue *value;
const GValue *value1;
gboolean allok = TRUE;
gboolean hasfields = FALSE;
gint nrows;
gint i;
gboolean first;
GSList *pkfields = NULL; /* list of GValue* composing the pkey */
gint nbpkfields = 0;
gchar *sql = NULL;
gchar *conflict_algo = NULL;
gchar *tmp;
/* CREATE TABLE */
string = g_string_new ("CREATE ");
value = gda_server_operation_get_value_at (op, "/TABLE_DEF_P/TABLE_TEMP");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "TEMP ");
g_string_append (string, "TABLE ");
value = gda_server_operation_get_value_at (op, "/TABLE_DEF_P/TABLE_IFNOTEXISTS");
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, "IF NOT EXISTS ");
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op, "/TABLE_DEF_P/TABLE_NAME", error);
if (!tmp) {
g_string_free (string, TRUE);
if (error != NULL) {
if (*error == NULL) {
g_warning (_("Internal error, creating table in SQLite provider"));
}
}
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
g_string_append (string, " (");
GdaServerOperationNode *node;
/* FIELDS */
if (allok) {
node = gda_server_operation_get_node_info (op, "/FIELDS_A");
if (node == NULL) {
g_set_error (error, GDA_SERVER_OPERATION_ERROR, GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR,
"%s", _("No fields are defined for CREATE TABLE operation"));
return NULL;
}
/* finding if there is a composed primary key */
nrows = gda_data_model_get_n_rows (node->model);
for (i = 0; i < nrows; i++) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) {
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op,
"/FIELDS_A/@COLUMN_NAME/%d", error,
i);
if (!tmp) {
g_string_free (string, TRUE);
g_assert (*error != NULL);
return NULL;
}
pkfields = g_slist_append (pkfields, tmp);
nbpkfields++;
}
}
/* manually defined fields */
first = TRUE;
for (i = 0; i < nrows; i++) {
gboolean pkautoinc = FALSE;
hasfields = TRUE;
if (first)
first = FALSE;
else
g_string_append (string, ", ");
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op,
"/FIELDS_A/@COLUMN_NAME/%d", error, i);
if (!tmp) {
g_string_free (string, TRUE);
g_assert (*error != NULL);
return NULL;
}
g_string_append (string, tmp);
g_free (tmp);
g_string_append_c (string, ' ');
if (nbpkfields == 1) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_AUTOINC/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) {
const gchar *tmp;
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_TYPE/%d", i);
tmp = g_value_get_string (value);
if (!g_ascii_strcasecmp (tmp, "gint") ||
!g_ascii_strcasecmp (tmp, "int")) {
g_string_append (string, "INTEGER PRIMARY KEY AUTOINCREMENT");
pkautoinc = TRUE;
}
}
}
if (!pkautoinc) {
value1 = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_TYPE/%d", i);
g_string_append (string, g_value_get_string (value1));
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_SIZE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_UINT)) {
g_string_append_printf (string, "(%d", g_value_get_uint (value));
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_SCALE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_UINT))
g_string_append_printf (string, ",%d)", g_value_get_uint (value));
else
g_string_append (string, ")");
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_DEFAULT/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " DEFAULT ");
const gchar* valtmp = g_value_get_string (value1);
if (!g_ascii_strcasecmp (valtmp,"string") ||
!g_ascii_strcasecmp (valtmp,"gchararray")) {
g_string_append_c (string,'\'');
g_string_append (string, str);
g_string_append_c (string,'\'');
}
else {
g_string_append (string, str);
}
}
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_NNUL/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " NOT NULL");
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_UNIQUE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " UNIQUE");
if (nbpkfields == 1) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) {
g_string_append (string, " PRIMARY KEY");
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_CONFLICT/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " ON CONFLICT ");
g_string_append (string, str);
}
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_AUTOINC/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) {
g_string_append (string, " AUTOINCREMENT");
}
}
}
else {
if (!conflict_algo) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_CONFLICT/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str)
conflict_algo = g_strdup (str);
}
}
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_CHECK/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " CHECK (");
g_string_append (string, str);
g_string_append_c (string, ')');
}
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_COLLATE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " COLLATE ");
g_string_append (string, str);
}
}
}
}
}
/* composed primary key */
if (nbpkfields > 1) {
GSList *list;
g_string_append (string, ", PRIMARY KEY (");
for (list = pkfields; list; list = list->next) {
if (list != pkfields)
g_string_append (string, ", ");
g_string_append (string, (gchar *) list->data);
}
g_string_append_c (string, ')');
if (conflict_algo) {
g_string_append (string, " ON CONFLICT ");
g_string_append (string, conflict_algo);
}
}
g_slist_free_full (pkfields, (GDestroyNotify) g_free);
node = gda_server_operation_get_node_info (op, "/FKEY_S");
if (node) {
nrows = gda_server_operation_get_sequence_size (op, "/FKEY_S");
for (i = 0; i < nrows; i++) {
gint nbfields = 0, j;
g_string_append (string, ", FOREIGN KEY (");
node = gda_server_operation_get_node_info (op, "/FKEY_S/%d/FKEY_FIELDS_A", i);
if (!node || ((nbfields = gda_data_model_get_n_rows (node->model)) == 0)) {
g_string_free (string, TRUE);
g_set_error (error, GDA_SERVER_OPERATION_ERROR,
GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR,
"%s", _("No field specified in foreign key constraint"));
return NULL;
}
else {
for (j = 0; j < nbfields; j++) {
if (j != 0)
g_string_append (string, ", ");
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op,
"/FKEY_S/%d/FKEY_FIELDS_A/@FK_FIELD/%d",
error, i, j);
if (tmp) {
g_string_append (string, tmp);
g_free (tmp);
}
else {
g_string_free (string, TRUE);
return NULL;
}
}
}
g_string_append (string, ") REFERENCES ");
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op,
"/FKEY_S/%d/FKEY_REF_TABLE", error, i);
if (tmp) {
g_string_append (string, tmp);
g_free (tmp);
}
else {
g_string_free (string, TRUE);
return NULL;
}
g_string_append (string, " (");
for (j = 0; j < nbfields; j++) {
if (j != 0)
g_string_append (string, ", ");
tmp = gda_connection_operation_get_sql_identifier_at (cnc, op,
"/FKEY_S/%d/FKEY_FIELDS_A/@FK_REF_PK_FIELD/%d",
error, i, j);
if (tmp) {
g_string_append (string, tmp);
g_free (tmp);
}
else {
g_string_free (string, TRUE);
return NULL;
}
}
g_string_append_c (string, ')');
value = gda_server_operation_get_value_at (op, "/FKEY_S/%d/FKEY_MATCH_TYPE", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value))
g_string_append_printf (string, " %s", g_value_get_string (value));
value = gda_server_operation_get_value_at (op, "/FKEY_S/%d/FKEY_ONUPDATE", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value))
g_string_append_printf (string, " ON UPDATE %s", g_value_get_string (value));
value = gda_server_operation_get_value_at (op, "/FKEY_S/%d/FKEY_ONDELETE", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING) && g_value_get_string (value))
g_string_append_printf (string, " ON DELETE %s", g_value_get_string (value));
}
}
g_free (conflict_algo);
g_string_append (string, ")");
if (!hasfields) {
allok = FALSE;
g_set_error (error, GDA_SERVER_OPERATION_ERROR,
GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR,
"%s", _("Table to create must have at least one field"));
g_string_free (string, TRUE);
return NULL;
}
sql = string->str;
g_string_free (string, FALSE);
#ifdef GDA_DEBUG
g_print ("Renderer SQL for SQLite: %s\n", sql);
#endif
return sql;
}
GtkWidget *
do_form_model_change (GtkWidget *do_widget)
{
if (!window) {
GdaStatement *stmt;
GtkWidget *vbox;
GtkWidget *label;
GdaDataModel *models [3];
window = gtk_dialog_new_with_buttons ("Changing data in a GdauiForm",
GTK_WINDOW (do_widget),
0,
"Close", GTK_RESPONSE_NONE,
NULL);
g_signal_connect (window, "response",
G_CALLBACK (gtk_widget_destroy), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
vbox, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
label = gtk_label_new ("The data in the same GdauiForm widget can be change don the fly.");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
/* creating data models */
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products ORDER BY ref, category LIMIT 15", NULL, NULL);
models[0] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[0]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT * FROM products WHERE price > 20.2 ORDER BY ref, category LIMIT 10", NULL, NULL);
models[1] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[1]), NULL);
g_object_unref (stmt);
stmt = gda_sql_parser_parse_string (demo_parser, "SELECT name, price, ref, category FROM products WHERE price > 20.2 ORDER BY name LIMIT 30", NULL, NULL);
models[2] = gda_connection_statement_execute_select (demo_cnc, stmt, NULL, NULL);
gda_data_select_compute_modification_statements (GDA_DATA_SELECT (models[2]), NULL);
g_object_unref (stmt);
/* allow choosing which data model to display */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>Choose which data model to display:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
GtkWidget *layout, *rb;
GSList *group = NULL;
gint i;
layout = gtk_grid_new ();
gtk_box_pack_start (GTK_BOX (vbox), layout, FALSE, FALSE, 0);
for (i = 0; i < 3; i++) {
gchar *str;
str = g_strdup_printf ("%d columns x %d rows", gda_data_model_get_n_columns (models[i]),
gda_data_model_get_n_rows (models[i]));
rb = gtk_radio_button_new_with_label (group, str);
g_free (str);
gtk_grid_attach (GTK_GRID (layout), rb, i, 0, 1, 1);
g_signal_connect (rb, "toggled", G_CALLBACK (model_toggled_cb), models[i]);
g_object_set_data_full (G_OBJECT (rb), "model", models[i], g_object_unref);
group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (rb));
}
/* Create the form widget */
label = gtk_label_new ("");
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_markup (GTK_LABEL (label), "<b>GdauiForm:</b>");
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
form = gdaui_form_new (models[0]);
g_object_set (G_OBJECT (form), "info-flags",
GDAUI_DATA_PROXY_INFO_CURRENT_ROW |
GDAUI_DATA_PROXY_INFO_ROW_MOVE_BUTTONS |
GDAUI_DATA_PROXY_INFO_ROW_MODIFY_BUTTONS, NULL);
gtk_box_pack_start (GTK_BOX (vbox), form, TRUE, TRUE, 0);
GdaDataProxy *proxy;
proxy = gdaui_data_proxy_get_proxy (GDAUI_DATA_PROXY (form));
g_object_set (proxy, "cache-changes", TRUE, NULL);
}
gboolean visible;
g_object_get (G_OBJECT (window), "visible", &visible, NULL);
if (!visible)
gtk_widget_show_all (window);
else {
gtk_widget_destroy (window);
window = NULL;
}
return window;
}
gchar *
gda_capi_render_CREATE_TABLE (GdaServerProvider *provider, GdaConnection *cnc,
GdaServerOperation *op, GError **error)
{
GString *string;
const GValue *value;
gboolean allok = TRUE;
gboolean hasfields = FALSE;
gint nrows;
gint i;
gboolean first;
GSList *pkfields = NULL; /* list of GValue* composing the pkey */
gint nbpkfields = 0;
gchar *tmp;
/* CREATE TABLE */
string = g_string_new ("CREATE TABLE ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/TABLE_DEF_P/TABLE_NAME");
g_string_append (string, tmp);
g_free (tmp);
g_string_append (string, " (");
/* FIELDS */
if (allok) {
GdaServerOperationNode *node;
node = gda_server_operation_get_node_info (op, "/FIELDS_A");
g_assert (node);
/* finding if there is a composed primary key */
nrows = gda_data_model_get_n_rows (node->model);
for (i = 0; i < nrows; i++) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) {
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FIELDS_A/@COLUMN_NAME/%d", i);
pkfields = g_slist_append (pkfields, tmp);
nbpkfields++;
}
}
/* manually defined fields */
first = TRUE;
for (i = 0; i < nrows; i++) {
hasfields = TRUE;
if (first)
first = FALSE;
else
g_string_append (string, ", ");
tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider,
"/FIELDS_A/@COLUMN_NAME/%d", i);
g_string_append (string, tmp);
g_free (tmp);
g_string_append_c (string, ' ');
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_TYPE/%d", i);
g_string_append (string, g_value_get_string (value));
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_DEFAULT/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " DEFAULT ");
g_string_append (string, str);
}
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_NNUL/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " NOT NULL");
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_UNIQUE/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " UNIQUE");
if (nbpkfields == 1) {
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value))
g_string_append (string, " PRIMARY KEY");
}
value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_CHECK/%d", i);
if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) {
const gchar *str = g_value_get_string (value);
if (str && *str) {
g_string_append (string, " CHECK (");
g_string_append (string, str);
g_string_append_c (string, ')');
}
}
}
}
/* composed primary key */
if (nbpkfields > 1) {
GSList *list;
g_string_append (string, ", PRIMARY KEY (");
for (list = pkfields; list; list = list->next) {
if (list != pkfields)
g_string_append (string, ", ");
g_string_append (string, (gchar*) list->data);
}
g_string_append_c (string, ')');
}
g_slist_foreach (pkfields, (GFunc) g_free, NULL);
g_slist_free (pkfields);
g_string_append (string, ")");
if (!hasfields) {
allok = FALSE;
g_set_error (error, GDA_SERVER_OPERATION_ERROR,
GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR,
"%s", _("Table to create must have at least one row"));
}
return g_string_free (string, FALSE);
}
/**
* base_tool_output_data_model_to_string:
*/
gchar *
base_tool_output_data_model_to_string (GdaDataModel *model, ToolOutputFormat format, FILE *stream, GdaSet *options)
{
if (!GDA_IS_DATA_MODEL (model))
return NULL;
if (format & BASE_TOOL_OUTPUT_FORMAT_DEFAULT) {
gchar *tmp;
GdaSet *local_options;
gint width;
base_tool_input_get_size (&width, NULL);
local_options = gda_set_new_inline (6, "NAME", G_TYPE_BOOLEAN, TRUE,
"NULL_AS_EMPTY", G_TYPE_BOOLEAN, TRUE,
"MAX_WIDTH", G_TYPE_INT, width,
"COLUMN_SEPARATORS", G_TYPE_BOOLEAN, TRUE,
"SEPARATOR_LINE", G_TYPE_BOOLEAN, TRUE,
"NAMES_ON_FIRST_LINE", G_TYPE_BOOLEAN, TRUE);
if (options)
gda_set_merge_with_set (local_options, options);
tmp = gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_TEXT_TABLE, NULL, 0, NULL, 0,
local_options);
g_object_unref (local_options);
if (GDA_IS_DATA_SELECT (model)) {
gchar *tmp2, *tmp3;
gdouble etime;
g_object_get ((GObject*) model, "execution-delay", &etime, NULL);
tmp2 = g_strdup_printf ("%s: %.03f s", _("Execution delay"), etime);
tmp3 = g_strdup_printf ("%s\n%s", tmp, tmp2);
g_free (tmp);
g_free (tmp2);
return tmp3;
}
else
return tmp;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_XML)
return gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_DATA_ARRAY_XML,
NULL, 0,
NULL, 0, NULL);
else if (format & BASE_TOOL_OUTPUT_FORMAT_CSV) {
gchar *retval;
GdaSet *optexp;
optexp = make_options_set_from_string ("csv", options);
retval = gda_data_model_export_to_string (model, GDA_DATA_MODEL_IO_TEXT_SEPARATED,
NULL, 0,
NULL, 0, optexp);
if (optexp)
g_object_unref (optexp);
return retval;
}
else if (format & BASE_TOOL_OUTPUT_FORMAT_HTML) {
xmlBufferPtr buffer;
xmlNodePtr top, div, table, node, row_node, col_node, header, meta;
gint ncols, nrows, i, j;
gchar *str;
top = xmlNewNode (NULL, BAD_CAST "html");
header = xmlNewChild (top, NULL, BAD_CAST "head", NULL);
meta = xmlNewChild (header, NULL, BAD_CAST "meta", NULL);
xmlSetProp (meta, BAD_CAST "http-equiv", BAD_CAST "content-type");
xmlSetProp (meta, BAD_CAST "content", BAD_CAST "text/html; charset=UTF-8");
div = xmlNewChild (top, NULL, BAD_CAST "body", NULL);
table = xmlNewChild (div, NULL, BAD_CAST "table", NULL);
xmlSetProp (table, BAD_CAST "border", BAD_CAST "1");
if (g_object_get_data (G_OBJECT (model), "name"))
xmlNewTextChild (table, NULL, BAD_CAST "caption", g_object_get_data (G_OBJECT (model), "name"));
ncols = gda_data_model_get_n_columns (model);
nrows = gda_data_model_get_n_rows (model);
row_node = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
for (j = 0; j < ncols; j++) {
const gchar *cstr;
cstr = gda_data_model_get_column_title (model, j);
col_node = xmlNewTextChild (row_node, NULL, BAD_CAST "th", BAD_CAST cstr);
xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "center");
}
for (i = 0; i < nrows; i++) {
row_node = xmlNewChild (table, NULL, BAD_CAST "tr", NULL);
xmlSetProp (row_node, BAD_CAST "valign", BAD_CAST "top");
for (j = 0; j < ncols; j++) {
const GValue *value;
value = gda_data_model_get_value_at (model, j, i, NULL);
if (!value) {
col_node = xmlNewChild (row_node, NULL, BAD_CAST "td", BAD_CAST "ERROR");
xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "left");
}
else {
str = gda_value_stringify (value);
col_node = xmlNewTextChild (row_node, NULL, BAD_CAST "td", BAD_CAST str);
xmlSetProp (col_node, BAD_CAST "align", BAD_CAST "left");
g_free (str);
}
}
}
node = xmlNewChild (div, NULL, BAD_CAST "p", NULL);
str = g_strdup_printf (ngettext ("(%d row)", "(%d rows)", nrows), nrows);
xmlNodeSetContent (node, BAD_CAST str);
g_free (str);
buffer = xmlBufferCreate ();
xmlNodeDump (buffer, NULL, top, 0, 1);
str = g_strdup ((gchar *) xmlBufferContent (buffer));
xmlBufferFree (buffer);
xmlFreeNode (top);
return str;
}
else
TO_IMPLEMENT;
return NULL;
}
int
main (int argc, char *argv [])
{
GdaDataModel *model;
gint i, nrows;
GError *error = NULL;
gda_init ();
if (! g_file_test (DATABASE, G_FILE_TEST_EXISTS)) {
g_print ("File '%s' does not exist\n", DATABASE);
exit (1);
}
model = gda_data_model_bdb_new (DATABASE, NULL);
gda_data_model_dump (model, stdout);
nrows = gda_data_model_get_n_rows (model);
for (i = 0; i < nrows; i++) {
Key *key;
Value *value;
const GValue *c_value;
const GdaBinary *bin;
g_print ("=============== ROW %d\n", i);
c_value= gda_data_model_get_value_at (model, 0, i, &error);
if (!c_value) {
g_print ("Could not get value from data model: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
bin = gda_value_get_binary (c_value);
key = (Key *)bin->data;
g_print ("color/type = %s/%d\n", key->color, key->type);
c_value= gda_data_model_get_value_at (model, 1, i, &error);
if (!c_value) {
g_print ("Could not get value from data model: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
bin = gda_value_get_binary (c_value);
value = (Value *)bin->data;
g_print ("size/name = %f/%s\n", value->size, value->name);
}
i = gda_data_model_append_row (model, &error);
if (i < 0) {
g_print ("Could not append row: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
else {
{
/* EXTRA tests */
gda_data_model_dump (model, stdout);
if (!gda_data_model_remove_row (model, i, &error)) {
g_print ("Could not remove row: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_data_model_dump (model, stdout);
gchar *str = "AAA";
GValue *value = gda_value_new_binary ((guchar*) str, 4);
if (!gda_data_model_set_value_at (model, 1, 2, value, &error)) {
g_print ("Could not set value: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_data_model_dump (model, stdout);
exit (0);
}
GValue *value;
GdaBinary bin;
Key m_key;
Value m_value;
strncpy (m_key.color, "black", COLORSIZE);
m_key.type = 100;
bin.data = (gpointer) &m_key;
bin.binary_length = sizeof (Key);
value = gda_value_new (GDA_TYPE_BINARY);
gda_value_set_binary (value, &bin);
if (!gda_data_model_set_value_at (model, 0, i, value, &error)) {
g_print ("Could not set key: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_value_free (value);
m_value.size = 100.1;
strncpy (m_value.name, "blackhole", NAMESIZE);
bin.data = (gpointer) &m_value;
bin.binary_length = sizeof (Value);
value = gda_value_new (GDA_TYPE_BINARY);
gda_value_set_binary (value, &bin);
if (!gda_data_model_set_value_at (model, 1, i, value, &error)) {
g_print ("Could not set key: %s\n",
error && error->message ? error->message : "no detail");
exit (1);
}
gda_value_free (value);
}
g_object_unref (model);
return 0;
}
