257 lines
6.4 KiB
C
257 lines
6.4 KiB
C
/*
|
|
* Copyright (C) 2012 - Juan Ferrer Toribio
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "db-sqlite.h"
|
|
#include <stdlib.h>
|
|
|
|
/**
|
|
* SECTION: db-sqlite
|
|
* @Short_description: manages a connection to a SQLite database.
|
|
* @Title: DbSqlite
|
|
* @See_also: #DbConn
|
|
*
|
|
* This class manages a connection to a SQLite database internally. This
|
|
* is accessed through the #DbConn class to internally connect, query and
|
|
* disconnect the database.
|
|
**/
|
|
G_DEFINE_TYPE (DbSqlite, db_sqlite, DB_TYPE_PLUGIN);
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++ Private
|
|
|
|
static void db_sqlite_close (DbSqlite * self)
|
|
{
|
|
if (self->sqlite)
|
|
{
|
|
sqlite3_close (self->sqlite);
|
|
self->sqlite = NULL;
|
|
}
|
|
}
|
|
|
|
static gboolean db_sqlite_open (DbSqlite * self, const gchar * host,
|
|
const gchar * schema, const gchar * user, const gchar * pass, GError ** err)
|
|
{
|
|
db_sqlite_close (self);
|
|
sqlite3_open (schema, &self->sqlite);
|
|
|
|
if (!self->sqlite)
|
|
{
|
|
g_set_error (err
|
|
,DB_CONN_LOG_DOMAIN
|
|
,DB_CONN_ERROR_OPENING
|
|
,"%s", sqlite3_errmsg (self->sqlite)
|
|
);
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void db_sqlite_set_ssl (DbSqlite * self, const gchar * ca)
|
|
{
|
|
g_warning ("DbSqlite: SSL not supported by this plugin");
|
|
}
|
|
|
|
static DbResultSet * db_sqlite_query (DbSqlite * self, const gchar * sql, GError ** err)
|
|
{
|
|
gint i, j;
|
|
gint status;
|
|
sqlite3_stmt * stmt;
|
|
GValue def = G_VALUE_INIT;
|
|
DbResult * result;
|
|
DbResultSet * set = db_result_set_new ();
|
|
|
|
while (sql)
|
|
{
|
|
status = sqlite3_prepare_v2 (self->sqlite, sql, -1, &stmt, &sql);
|
|
|
|
if (status != SQLITE_OK)
|
|
break;
|
|
|
|
status = sqlite3_step (stmt);
|
|
|
|
if (status != SQLITE_DONE && status != SQLITE_ROW)
|
|
{
|
|
sqlite3_finalize (stmt);
|
|
break;
|
|
}
|
|
|
|
result = g_new (DbResult, 1);
|
|
result->ncols = sqlite3_column_count (stmt);
|
|
set->results = g_slist_append (set->results, result);
|
|
|
|
// INSERT, DELETE or UPDATE
|
|
|
|
if (result->ncols == 0)
|
|
{
|
|
result->nrows = sqlite3_changes (self->sqlite);
|
|
result->column = NULL;
|
|
result->data = NULL;
|
|
sqlite3_finalize (stmt);
|
|
continue;
|
|
}
|
|
|
|
// SELECT
|
|
|
|
result->nrows = 0;
|
|
result->column = g_new (DbColumn, result->ncols);
|
|
result->data = g_ptr_array_new_full (2,
|
|
(GDestroyNotify) db_row_free);
|
|
|
|
GType gtypes[result->ncols];
|
|
|
|
for (i = 0; i < result->ncols; i++)
|
|
{
|
|
DbColumn * column = &result->column[i];
|
|
column->info = 0;
|
|
column->name = g_strdup (sqlite3_column_origin_name (stmt, i));
|
|
column->alias = g_strdup (sqlite3_column_name (stmt, i));
|
|
column->table = g_strdup (sqlite3_column_table_name (stmt, i));
|
|
column->table_alias = g_strdup (column->table);
|
|
column->schema = g_strdup (sqlite3_column_database_name (stmt, i));
|
|
|
|
if (!column->alias)
|
|
column->alias = g_strdup (column->name);
|
|
|
|
switch (sqlite3_column_type (stmt, i))
|
|
{
|
|
case SQLITE_INTEGER:
|
|
gtypes[i] = G_TYPE_INT;
|
|
break;
|
|
case SQLITE_FLOAT:
|
|
gtypes[i] = G_TYPE_DOUBLE;
|
|
break;
|
|
case SQLITE_BLOB:
|
|
gtypes[i] = G_TYPE_BYTES;
|
|
break;
|
|
case SQLITE_TEXT:
|
|
case SQLITE_NULL: // TODO
|
|
default:
|
|
gtypes[i] = G_TYPE_STRING;
|
|
break;
|
|
}
|
|
|
|
if (!g_strcmp0 (column->name, "rowid"))
|
|
{
|
|
SqlObject * func = sql_function_new ("last_insert_rowid", NULL);
|
|
|
|
g_value_init (&def, SQL_TYPE_FUNCTION);
|
|
g_value_take_object (&def, g_object_ref_sink (func));
|
|
|
|
column->info |= DB_COLUMN_PRI_KEY;
|
|
}
|
|
else
|
|
g_value_init (&def, GVN_TYPE_NULL);
|
|
|
|
column->spec = gvn_param_spec_new_with_attrs (gtypes[i], FALSE, TRUE, &def);
|
|
g_value_unset (&def);
|
|
}
|
|
|
|
for (i = 0; status == SQLITE_ROW; i++)
|
|
{
|
|
DbRow * row = db_row_new (result->ncols, i);
|
|
g_ptr_array_add (result->data, row);
|
|
|
|
for (j = 0; j < result->ncols; j++)
|
|
if (sqlite3_column_type (stmt, j) != SQLITE_NULL)
|
|
{
|
|
GValue * value = &row->value[j];
|
|
g_value_init (value, gtypes[j]);
|
|
|
|
switch (gtypes[j])
|
|
{
|
|
case G_TYPE_INT:
|
|
g_value_set_int (value, sqlite3_column_int (stmt, j));
|
|
break;
|
|
case G_TYPE_DOUBLE:
|
|
g_value_set_double (value, sqlite3_column_double (stmt, j));
|
|
break;
|
|
case G_TYPE_STRING:
|
|
g_value_set_string (value, (gchar *) sqlite3_column_text (stmt, j));
|
|
break;
|
|
default:
|
|
if (gtypes[i] == G_TYPE_BYTES)
|
|
{
|
|
int len = sqlite3_column_bytes (stmt, j);
|
|
const void * blob = sqlite3_column_blob (stmt, j);
|
|
g_value_take_boxed (value, g_bytes_new (blob, len));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
g_value_init (&row->value[j], GVN_TYPE_NULL);
|
|
|
|
status = sqlite3_step (stmt);
|
|
}
|
|
|
|
result->nrows = i;
|
|
sqlite3_finalize (stmt);
|
|
}
|
|
|
|
if (sqlite3_errcode (self->sqlite) != SQLITE_OK)
|
|
{
|
|
db_result_set_free (set);
|
|
set = NULL;
|
|
|
|
g_set_error (err
|
|
,DB_CONN_LOG_DOMAIN
|
|
,DB_CONN_ERROR_UNKNOW
|
|
,"%s", sqlite3_errmsg (self->sqlite)
|
|
);
|
|
}
|
|
|
|
return set;
|
|
}
|
|
|
|
static void db_sqlite_kill_query (DbSqlite * self)
|
|
{
|
|
g_warning ("DbSqlite: Kill not supported by this plugin");
|
|
}
|
|
|
|
static void db_sqlite_value_render (SqlValue * self, SqlRender * render, SqlBatch * batch)
|
|
{
|
|
if (G_VALUE_TYPE (self->value) == G_TYPE_BYTES)
|
|
{
|
|
// TODO: Render binary data
|
|
g_warning ("DbSqlite: Can't render binary data");
|
|
sql_render_set_error (render);
|
|
}
|
|
else
|
|
sql_object_render (SQL_OBJECT (self), render, batch);
|
|
}
|
|
|
|
//+++++++++++++++++++++++++++++++++++++++++++++++++++ Class
|
|
|
|
static void db_sqlite_init (DbSqlite * self)
|
|
{
|
|
SqlRender * render = sql_render_new ('`');
|
|
sql_render_register_function (render, SQL_TYPE_VALUE,
|
|
(SqlRenderFunc) db_sqlite_value_render);
|
|
|
|
DB_PLUGIN (self)->render = render;
|
|
self->sqlite = NULL;
|
|
}
|
|
|
|
static void db_sqlite_class_init (DbSqliteClass * k)
|
|
{
|
|
DbPluginClass * klass = DB_PLUGIN_CLASS (k);
|
|
klass->open = (DbPluginOpenFunc) db_sqlite_open;
|
|
klass->close = (DbPluginCloseFunc) db_sqlite_close;
|
|
klass->set_ssl = (DbPluginSetSSL) db_sqlite_set_ssl;
|
|
klass->query = (DbPluginQueryFunc) db_sqlite_query;
|
|
klass->kill_query = (DbPluginKillQueryFunc) db_sqlite_kill_query;
|
|
}
|