/*
* Open a connection to the example.db file
*/
GdaConnection *
open_connection ()
{
GdaConnection *cnc;
GError *error = NULL;
/* open connection */
cnc = gda_connection_open_from_dsn ("SalesTest", NULL,
GDA_CONNECTION_OPTIONS_NONE,
&error);
if (!cnc) {
g_print ("Could not open connection: %s\n",
error && error->message ? error->message : "No detail");
exit (1);
}
/* create an SQL parser */
parser = gda_connection_create_parser (cnc);
if (!parser) /* @cnc does not provide its own parser => use default one */
parser = gda_sql_parser_new ();
/* attach the parser object to the connection */
g_object_set_data_full (G_OBJECT (cnc), "parser", parser, g_object_unref);
return cnc;
}
GdaDataModel *
run_sql_select_cursor (GdaConnection *cnc, const gchar *sql)
{
GdaStatement *stmt;
GError *error = NULL;
GdaDataModel *res;
GdaSqlParser *parser;
parser = gda_connection_create_parser (cnc);
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
g_object_unref (parser);
res = gda_connection_statement_execute_select_full (cnc, stmt, NULL, GDA_STATEMENT_MODEL_CURSOR_FORWARD,
NULL, &error);
g_object_unref (stmt);
if (!res)
g_print ("Could not execute query in cursor mode: %s\n",
error && error->message ? error->message : "no detail");
return res;
}
/*
* Returns: the number of failures
*/
static gint
do_test (const xmlChar *id, const xmlChar *sql, gboolean valid_expected)
{
static GdaSqlParser *parser = NULL;
GdaStatement *stmt;
gboolean is_valid;
GError *error = NULL;
if (!parser) {
parser = gda_connection_create_parser (cnc);
if (!parser)
parser = gda_sql_parser_new ();
}
#ifdef GDA_DEBUG
g_print ("===== TEST %s SQL: @%s@\n", id, sql);
#endif
stmt = gda_sql_parser_parse_string (parser, (const gchar*) sql, NULL, NULL);
if (!stmt) {
g_print ("ERROR for test '%s': could not parse statement\n", id);
return FALSE;
}
is_valid = gda_statement_check_validity (stmt, cnc, &error);
if (is_valid && !valid_expected) {
g_print ("ERROR for test '%s': statement is valid but test expected it invalid\n", id);
g_object_unref (stmt);
return FALSE;
}
if (!is_valid && valid_expected) {
g_print ("ERROR for test '%s': statement is invalid but test expected it valid: %s\n", id,
error && error->message ? error->message : "No detail");
g_object_unref (stmt);
return FALSE;
}
/*g_print ("EXP %d, got %d\n", valid_expected, is_valid);*/
/*g_print ("PARSED: %s\n", gda_statement_serialize (stmt));*/
g_object_unref (stmt);
return TRUE;
}
/*
* display the contents of the 'products' table
*/
void
display_products_contents (GdaConnection *cnc)
{
GdaDataModel *data_model;
GdaStatement *stmt;
gchar *sql = "SELECT * FROM products";
GError *error = NULL;
GdaSqlParser *parser;
parser = gda_connection_create_parser (cnc);
if (!parser) /* @cnc doe snot provide its own parser => use default one */
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
data_model = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!data_model)
g_error ("Could not get the contents of the 'products' table: %s\n",
error && error->message ? error->message : "No detail");
gda_data_model_dump (data_model, stdout);
g_object_unref (data_model);
}
GdaDataModel *
run_sql_select (GdaConnection *cnc, const gchar *sql)
{
GdaStatement *stmt;
GError *error = NULL;
GdaDataModel *res;
GdaSqlParser *parser;
parser = gda_connection_create_parser (cnc);
if (!parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
g_object_unref (parser);
res = gda_connection_statement_execute_select (cnc, stmt, NULL, &error);
g_object_unref (stmt);
if (!res)
g_print ("Could not execute query: %s\n",
error && error->message ? error->message : "no detail");
return res;
}
gboolean
run_sql_non_select (GdaConnection *cnc, const gchar *sql)
{
GdaStatement *stmt;
GError *error = NULL;
gint nrows;
GdaSqlParser *parser;
parser = gda_connection_create_parser (cnc);
if (!parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser, sql, NULL, NULL);
g_object_unref (parser);
nrows = gda_connection_statement_execute_non_select (cnc, stmt, NULL, NULL, &error);
g_object_unref (stmt);
if (nrows == -1) {
g_print ("NON SELECT error: %s\n", error && error->message ? error->message : "no detail");
if (error)
g_error_free (error);
return FALSE;
}
return TRUE;
}
GSList *
create_queries (GdaConnection *cnc)
{
GdaSqlParser *parser;
GdaStatement *stmt;
GSList *list = NULL;
parser = gda_connection_create_parser (cnc);
stmt = gda_sql_parser_parse_string (parser, "SELECT * FROM customers", NULL, NULL);
g_object_set_data ((GObject*) stmt, "name", "customers");
list = g_slist_prepend (list, stmt);
stmt = gda_sql_parser_parse_string (parser, "SELECT s.* FROM salesrep s "
"INNER JOIN customers c ON (s.id=c.default_served_by) "
"WHERE c.id=## /* name:\"customers/id\" type:gint */", NULL, NULL);
g_object_set_data ((GObject*) stmt, "name", "salesrep_for_customer");
list = g_slist_prepend (list, stmt);
g_object_unref (parser);
return list;
}
/*
* COMMAND: <gda_report_section>
*
* creates a new RunContext, then executes its children, and destroys the RunContext
*
* uses node's contents: yes
* requested attributes: "query_name"
*
* REM: either "query_name" or a <gda_report_query> sub node must be provided to create a data model.
*/
static gboolean
command_gda_report_section_run (GdaReportEngine *engine, xmlNodePtr node, GSList **created_nodes,
RunContext *context, GError **error)
{
xmlChar *qname;
RunContext *ctx = NULL;
/* compute stmt to push a RunContext */
qname = xmlGetProp (node, BAD_CAST "query_name");
if (qname) {
GdaStatement *stmt;
GdaConnection *cnc = NULL;
xmlChar *prop;
/* find statement */
stmt = run_context_find_stmt (engine, context, qname);
if (!stmt) {
g_set_error (error, 0, 0,
_("Unknown query '%s'"), qname);
xmlFree (qname);
return FALSE;
}
/* find which connection to use */
prop = xmlGetProp (node, BAD_CAST "cnc_name");
cnc = run_context_find_connection (engine, context, prop);
if (!cnc) {
if (prop) {
g_set_error (error, 0, 0,
_("No connection named '%s' found"), prop);
xmlFree (prop);
}
else
g_set_error (error, 0, 0, "%s",
_("No connection specified"));
return FALSE;
}
ctx = run_context_push_with_stmt (engine, context, cnc, stmt, (gchar *) qname, error);
xmlFree (qname);
}
else {
xmlNodePtr child;
for (child = node->children; child; child = child->next) {
if (!strcmp ((gchar *) child->name, "gda_report_query")) {
GdaStatement *stmt;
xmlChar *prop;
GdaConnection *cnc = NULL;
GdaSqlParser *parser = NULL;
/* find which connection to use */
prop = xmlGetProp (child, BAD_CAST "cnc_name");
cnc = run_context_find_connection (engine, context, prop);
if (!cnc) {
if (prop) {
g_set_error (error, 0, 0,
_("No connection named '%s' found"), prop);
xmlFree (prop);
}
else
g_set_error (error, 0, 0, "%s",
_("No connection specified"));
return FALSE;
}
/* parser object */
parser = g_object_get_data (G_OBJECT (cnc), "__gda_parser");
if (!parser) {
parser = gda_connection_create_parser (cnc);
g_object_set_data_full (G_OBJECT (cnc), "__gda_parser",
parser, g_object_unref);
}
/* statement */
stmt = gda_sql_parser_parse_string (parser, (gchar *) xmlNodeGetContent (child),
NULL, error);
if (!stmt)
return FALSE;
qname = xmlGetProp (child, BAD_CAST "query_name");
if (qname) {
ctx = run_context_push_with_stmt (engine, context, cnc,
stmt, (gchar *) qname, error);
xmlFree (qname);
}
else
ctx = run_context_push_with_stmt (engine, context, cnc,
stmt, "context", error);
if (ctx)
ctx->stmt = stmt;
else {
g_object_unref (stmt);
return FALSE;
}
break;
}
}
}
if (!ctx) {
g_set_error (error, 0, 0, "%s",
_("Query is not specified (not named and not defined)"));
return FALSE;
}
/* go for the children while iterating */
if (!real_run_at_node (engine, node->children, ctx, error)) {
run_context_pop (engine, ctx);
return FALSE;
}
else {
xmlNodePtr child;
for (child = node->children; child; child = node->children) {
xmlUnlinkNode (child);
*created_nodes = g_slist_prepend (*created_nodes, child);
}
}
*created_nodes = g_slist_reverse (*created_nodes);
run_context_pop (engine, ctx);
return TRUE;
}
/*
* 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;
}
gboolean __midgard_connection_open(
MidgardConnection *mgd,
GHashTable **hashtable, gboolean init_schema)
{
g_return_val_if_fail(mgd != NULL, FALSE);
MIDGARD_ERRNO_SET (mgd, MGD_ERR_OK);
gchar *host, *dbname, *dbuser, *dbpass, *loglevel, *tmpstr;
guint port = 0;
gchar *auth = NULL;
MidgardConfig *config = mgd->priv->config;
host = config->host;
dbname = config->database;
dbuser = config->dbuser;
dbpass = config->dbpass;
loglevel = config->loglevel;
port = config->dbport;
gboolean enable_threads = config->gdathreads;
/* Get 30% performance boost for non threaded applications */
if(!enable_threads)
g_setenv("LIBGDA_NO_THREADS", "yes", TRUE);
/* Initialize libgda */
gda_init ();
midgard_connection_set_loglevel(mgd, loglevel, NULL);
if(config->priv->dbtype == MIDGARD_DB_TYPE_SQLITE) {
gchar *path = NULL;
gchar *dbdir = config->dbdir;
if (!dbdir || *dbdir == '\0') {
const gchar *sqlite_dir[] = {"data", NULL};
path = midgard_core_config_build_path(sqlite_dir, NULL, TRUE);
} else {
path = g_strdup(dbdir);
}
tmpstr = g_strconcat("DB_DIR=", path, ";", "DB_NAME=", dbname, NULL);
g_free(path);
} else if (config->priv->dbtype == MIDGARD_DB_TYPE_ORACLE) {
GString *cnc = g_string_sized_new(100);
cnc_add_part(cnc, "TNSNAME", dbname, MGD_MYSQL_HOST);
cnc_add_part(cnc, "HOST", host, MGD_MYSQL_HOST);
cnc_add_part(cnc, "DB_NAME", dbname, MGD_MYSQL_DATABASE);
tmpstr = g_string_free(cnc, FALSE);
cnc = g_string_sized_new(100);
cnc_add_part(cnc, "USERNAME", dbuser, MGD_MYSQL_USERNAME);
cnc_add_part(cnc, "PASSWORD", dbpass, MGD_MYSQL_PASSWORD);
auth = g_string_free(cnc, FALSE);
} else {
GString *cnc = g_string_sized_new(100);
cnc_add_part(cnc, "HOST", host, MGD_MYSQL_HOST);
if (port > 0) {
GString *_strp = g_string_new("");
g_string_append_printf (_strp, "%d", port);
cnc_add_part (cnc, "PORT", _strp->str, "");
g_string_free (_strp, TRUE);
}
cnc_add_part(cnc, "DB_NAME", dbname, MGD_MYSQL_DATABASE);
tmpstr = g_string_free(cnc, FALSE);
GString *auth_str = g_string_sized_new(100);
cnc_add_part(auth_str, "USERNAME", dbuser, MGD_MYSQL_USERNAME);
cnc_add_part(auth_str, "PASSWORD", dbpass, MGD_MYSQL_PASSWORD);
auth = g_string_free(auth_str, FALSE);
}
GError *error = NULL;
GdaConnection *connection = gda_connection_open_from_string(
config->dbtype, tmpstr, auth, GDA_CONNECTION_OPTIONS_NONE, &error);
g_free(auth);
if(connection == NULL) {
MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_NOT_CONNECTED,
" Database [%s]. %s", tmpstr, error->message);
g_free(tmpstr);
return FALSE;
}
g_free(tmpstr);
mgd->priv->parser = gda_connection_create_parser (connection);
if (!mgd->priv->parser)
mgd->priv->parser = gda_sql_parser_new();
g_assert (mgd->priv->parser != NULL);
mgd->priv->connection = connection;
midgard_core_connection_connect_error_callback (mgd);
if(init_schema) {
if(!g_type_from_name("midgard_quota")) {
MidgardSchema *schema = g_object_new(MIDGARD_TYPE_SCHEMA, NULL);
gchar *path = g_build_path(G_DIR_SEPARATOR_S, config->sharedir, "MidgardObjects.xml", NULL);
midgard_schema_init(schema, (const gchar *)path);
g_free(path);
midgard_schema_read_dir(schema, config->sharedir);
mgd->priv->schema = schema;
}
}
//midgard_connection_set_loglevel(mgd, loglevel, NULL);
/* Loads available authentication types */
midgard_core_connection_initialize_auth_types(mgd);
g_signal_emit (mgd, MIDGARD_CONNECTION_GET_CLASS (mgd)->signal_id_connected, 0);
return TRUE;
}
static GSList *
gda_tree_mgr_columns_update_children (GdaTreeManager *manager, GdaTreeNode *node, G_GNUC_UNUSED const GSList *children_nodes,
gboolean *out_error, GError **error)
{
GdaTreeMgrColumns *mgr = GDA_TREE_MGR_COLUMNS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
GdaTreeMgrColumnsPrivate *priv = gda_tree_mgr_columns_get_instance_private (mgr);
if (!priv->cnc && !priv->mstore) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection and no GdaMetaStore specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
else if (priv->mstore)
store = priv->mstore;
else
store = gda_connection_get_meta_store (priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
/* create statements if necessary */
if (!priv->stmt) {
GdaSqlParser *parser;
GdaStatement *stmt;
parser = gda_connection_create_parser (scnc);
if (! parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser,
"SELECT column_name FROM _columns WHERE "
"table_schema= ##schema::string AND "
"table_name= ##table_name::string "
"ORDER BY ordinal_position", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!gda_statement_get_parameters (stmt, &(priv->params), error)) {
if (out_error)
*out_error = TRUE;
g_object_unref (stmt);
return NULL;
}
priv->stmt = stmt;
}
gboolean schema_specified = FALSE;
gboolean table_specified = FALSE;
if (priv->schema) {
schema_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "schema",
priv->schema));
}
if (priv->table_name) {
table_specified = TRUE;
g_assert (gda_set_set_holder_value (priv->params, NULL, "table_name",
priv->table_name));
}
if (!schema_specified && node) {
/* looking for a schema in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "schema");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "schema");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
schema_specified = TRUE;
}
}
if (!table_specified && node) {
/* looking for a table in @node's attributes */
const GValue *cvalue;
cvalue = gda_tree_node_fetch_attribute (node, "table_name");
if (cvalue) {
GdaHolder *h = gda_set_get_holder (priv->params, "table_name");
if (!gda_holder_set_value (h, cvalue, error)) {
if (out_error)
*out_error = TRUE;
return NULL;
}
table_specified = TRUE;
}
}
if (!schema_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No schema specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
if (!table_specified) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No table specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
model = gda_connection_statement_execute_select (scnc, priv->stmt, priv->params, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode;
const GValue *cvalue;
cvalue = gda_data_model_iter_get_value_at (iter, 0);
if (!cvalue) {
if (list) {
g_slist_free_full (list, (GDestroyNotify) g_object_unref);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get column name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "column_name", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
static GSList *
gda_tree_mgr_schemas_update_children (GdaTreeManager *manager, GdaTreeNode *node,
G_GNUC_UNUSED const GSList *children_nodes, gboolean *out_error,
GError **error)
{
GdaTreeMgrSchemas *mgr = GDA_TREE_MGR_SCHEMAS (manager);
GdaMetaStore *store;
GdaDataModel *model;
GSList *list = NULL;
GdaConnection *scnc;
if (!mgr->priv->cnc && !mgr->priv->mstore) {
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("No connection and no GdaMetaStore specified"));
if (out_error)
*out_error = TRUE;
return NULL;
}
else if (mgr->priv->mstore)
store = mgr->priv->mstore;
else
store = gda_connection_get_meta_store (mgr->priv->cnc);
scnc = gda_meta_store_get_internal_connection (store);
if (!mgr->priv->stmt) {
GdaSqlParser *parser;
GdaStatement *stmt;
parser = gda_connection_create_parser (scnc);
if (! parser)
parser = gda_sql_parser_new ();
stmt = gda_sql_parser_parse_string (parser,
"SELECT schema_name FROM _schemata "
"WHERE schema_internal = FALSE OR schema_name LIKE 'info%' "
"ORDER BY schema_name DESC", NULL, error);
g_object_unref (parser);
if (!stmt) {
if (out_error)
*out_error = TRUE;
return NULL;
}
mgr->priv->stmt = stmt;
}
model = gda_connection_statement_execute_select (scnc, mgr->priv->stmt, NULL, error);
if (!model) {
if (out_error)
*out_error = TRUE;
return NULL;
}
GdaDataModelIter *iter;
iter = gda_data_model_create_iter (model);
for (; iter && gda_data_model_iter_move_next (iter);) {
GdaTreeNode* snode;
const GValue *cvalue;
cvalue = gda_data_model_iter_get_value_at (iter, 0);
if (!cvalue) {
if (list) {
g_slist_foreach (list, (GFunc) g_object_unref, NULL);
g_slist_free (list);
}
if (out_error)
*out_error = TRUE;
g_set_error (error, GDA_TREE_MANAGER_ERROR, GDA_TREE_MANAGER_UNKNOWN_ERROR,
"%s", _("Unable to get schema name"));
return NULL;
}
snode = gda_tree_manager_create_node (manager, node, g_value_get_string (cvalue));
gda_tree_node_set_node_attribute (snode, "schema", cvalue, NULL);
list = g_slist_prepend (list, snode);
}
if (iter)
g_object_unref (iter);
g_object_unref (model);
return list;
}
int
main (int argc, char **argv)
{
GError *error = NULL;
GOptionContext *context;
GdaConnection *cnc;
gchar *auth_string = NULL;
gchar *blob_data;
/* command line parsing */
context = g_option_context_new ("Tests opening a connection");
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_warning ("Can't parse arguments: %s", error->message);
exit (1);
}
g_option_context_free (context);
if (direct && dsn) {
g_print ("DSN and connection string are exclusive\n");
exit (1);
}
if (!direct && !dsn) {
g_print ("You must specify a connection to open either as a DSN or a connection string\n");
exit (1);
}
if (direct && !prov) {
g_print ("You must specify a provider when using a connection string\n");
exit (1);
}
gda_init ();
/* open connection */
if (user) {
if (pass)
auth_string = g_strdup_printf ("USERNAME=%s;PASSWORD=%s", user, pass);
else
auth_string = g_strdup_printf ("USERNAME=%s", user);
}
if (dsn) {
GdaDsnInfo *info = NULL;
info = gda_config_get_dsn_info (dsn);
if (!info)
g_error (_("DSN '%s' is not declared"), dsn);
else {
cnc = gda_connection_open_from_dsn (info->name, auth_string ? auth_string : info->auth_string,
0, &error);
if (!cnc) {
g_warning (_("Can't open connection to DSN %s: %s\n"), info->name,
error && error->message ? error->message : "???");
exit (1);
}
prov = info->provider;
}
}
else {
cnc = gda_connection_open_from_string (prov, direct, auth_string, 0, &error);
if (!cnc) {
g_warning (_("Can't open specified connection: %s\n"),
error && error->message ? error->message : "???");
exit (1);
}
}
g_free (auth_string);
g_print (_("Connection successfully opened!\n"));
parser = gda_connection_create_parser (cnc);
gda_connection_begin_transaction (cnc, NULL, GDA_TRANSACTION_ISOLATION_UNKNOWN, NULL);
/*
* clear all blobs
*/
if (!clear_blobs (cnc, &error))
g_error ("Blobs clear error: %s", error && error->message ? error->message : "No detail");
/* insert a blob */
blob_data = "Blob Data 1";
if (!insert_blob (cnc, 1, blob_data, strlen (blob_data), &error))
g_error ("Blob insert error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
/* insert a blob */
blob_data = "Blob Data 2";
if (!insert_blob (cnc, 2, blob_data, strlen (blob_data), &error))
g_error ("Blob insert error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
if (!display_blobs (cnc, &error))
g_error ("Blobs display error: %s", error && error->message ? error->message : "No detail");
/* update blob */
blob_data = "New blob 1 contents is now this one...";
if (!update_blob (cnc, 1, blob_data, strlen (blob_data), &error))
g_error ("Blob update error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
if (!display_blobs (cnc, &error))
g_error ("Blobs display error: %s", error && error->message ? error->message : "No detail");
/* update blob */
blob_data = "After several blobs updated";
if (!update_multiple_blobs (cnc, blob_data, strlen (blob_data), &error))
g_error ("Multiple blob update error: %s", error && error->message ? error->message : "No detail");
else if (error) {
g_print ("Msg: %s\n", error->message);
g_error_free (error);
error = NULL;
}
if (!display_blobs (cnc, &error))
g_error ("Blobs display error: %s", error && error->message ? error->message : "No detail");
/* SQL Postgres:
create table blobs (id serial not null primary key, name varchar (50), data oid);
SQL Oracle:
CREATE TABLE blobs (id number primary key, name varchar2 (50), data BLOB);
*/
gda_connection_commit_transaction (cnc, NULL, NULL);
if (! gda_connection_close (cnc, &error))
g_error ("Can't close connection: %s", error && error->message ? error->message : "No detail");
return 0;
}
