QOF 0.7.5
|
Public interface of qof-backend-sqlite. More...
#include "config.h"
#include <errno.h>
#include <stdlib.h>
#include <time.h>
#include <glib/gstdio.h>
#include <sqlite.h>
#include <glib.h>
#include <libintl.h>
#include "qof.h"
Go to the source code of this file.
Defines | |
#define | _(String) dgettext (GETTEXT_PACKAGE, String) |
#define | ACCESS_METHOD "sqlite" |
#define | PRIORITY_HIGH 9 |
#define | PRIORITY_STANDARD 5 |
#define | PRIORITY_LOW 0 |
#define | QSQL_ERROR -1 |
#define | QSQL_KVP_TABLE "sqlite_kvp" |
#define | END_DB_VERSION " dbversion int );" |
Enumerations | |
enum | QsqlStatementType { SQL_NONE = 0, SQL_CREATE, SQL_LOAD, SQL_WRITE, SQL_INSERT, SQL_DELETE, SQL_UPDATE } |
Functions | |
static gchar * | add_to_sql (gchar *sql_str, const gchar *add) |
static QofIdTypeConst | kvp_value_to_qof_type_helper (KvpValueType n) |
Map a KvpValue to a QofIdType. | |
static KvpValueType | sql_to_kvp_helper (const gchar *type_string) |
KvpValue * | string_to_kvp_value (const gchar *content, KvpValueType type) |
Convert a string value into KvpValue. | |
static void | kvpvalue_to_sql (const gchar *key, KvpValue *val, gpointer builder) |
static gchar * | string_param_to_sql (QofParam *param) |
static void | create_param_list (QofParam *param, gpointer builder) |
list just the parameter names | |
static void | create_each_param (QofParam *param, gpointer builder) |
static void | delete_event (QofEntity *ent, QofEventId event_type, gpointer handler_data, gpointer event_data) |
use the new-style event handlers for insert and update insert runs after QOF_EVENT_CREATE delete runs before QOF_EVENT_DESTROY | |
static void | create_event (QofEntity *ent, QofEventId event_type, gpointer handler_data, gpointer event_data) |
static void | qsql_modify (QofBackend *be, QofInstance *inst) |
static gint | record_foreach (gpointer builder, gint col_num, gchar **strings, gchar **columnNames) |
static void | string_param_foreach (QofParam *param, gpointer builder) |
static void | update_param_foreach (QofParam *param, gpointer builder) |
static void | update_dirty (gpointer value, gpointer builder) |
static gint | create_dirty_list (gpointer builder, gint col_num, gchar **strings, gchar **columnNames) |
static gint | mark_entity (gpointer builder, gint col_num, gchar **strings, gchar **columnNames) |
static void | qsql_create (QofBackend *be, QofInstance *inst) |
static void | check_state (QofEntity *ent, gpointer builder) |
static gint | build_kvp_table (gpointer builder, gint col_num, gchar **strings, gchar **columnNames) |
chekc kvp data once per record | |
static void | qsql_load_kvp (QSQLiteBackend *qsql_be) |
static void | qsql_class_foreach (QofObject *obj, gpointer data) |
static void | qsql_backend_createdb (QofBackend *be, QofSession *session) |
static void | qsql_backend_opendb (QofBackend *be, QofSession *session) |
static void | qsqlite_session_begin (QofBackend *be, QofSession *session, const gchar *book_path, gboolean ignore_lock, gboolean create_if_nonexistent) |
static void | qsqlite_db_load (QofBackend *be, QofBook *book) |
static void | qsqlite_write_db (QofBackend *be, QofBook *book) |
static gboolean | qsql_determine_file_type (const gchar *path) |
static void | qsqlite_session_end (QofBackend *be) |
static void | qsqlite_destroy_backend (QofBackend *be) |
static void | qsql_provider_free (QofBackendProvider *prov) |
static QofBackend * | qsql_backend_new (void) |
Starts the backend and creates the context. | |
void | qof_sqlite_provider_init (void) |
Initialises the SQLite backend. | |
Variables | |
static QofLogModule | log_module = "qof-sqlite-module" |
static gboolean | loading = FALSE |
Public interface of qof-backend-sqlite.
Definition in file qof-sqlite.c.
#define PRIORITY_HIGH 9 |
Indicates an item with high priority.
Definition at line 43 of file qof-sqlite.c.
#define PRIORITY_LOW 0 |
Indicates a low priority item.
Definition at line 47 of file qof-sqlite.c.
#define PRIORITY_STANDARD 5 |
Indicates an item with default priority.
Definition at line 45 of file qof-sqlite.c.
#define QSQL_ERROR -1 |
Indicate an error to sqlite
Definition at line 49 of file qof-sqlite.c.
#define QSQL_KVP_TABLE "sqlite_kvp" |
One KVP table per file for all instances.
Definition at line 51 of file qof-sqlite.c.
enum QsqlStatementType |
Definition at line 58 of file qof-sqlite.c.
{ SQL_NONE = 0, SQL_CREATE, SQL_LOAD, SQL_WRITE, SQL_INSERT, SQL_DELETE, SQL_UPDATE } QsqlStatementType;
static gint build_kvp_table | ( | gpointer | builder, |
gint | col_num, | ||
gchar ** | strings, | ||
gchar ** | columnNames | ||
) | [static] |
chekc kvp data once per record
creates a new KvpFrame as data for a GHashTable with the guid as key
Definition at line 1076 of file qof-sqlite.c.
{ QSQLiteBackend *qsql_be; struct QsqlBuilder *qb; KvpFrame *frame; KvpValueType type; KvpValue *value; glong max; gchar *tail; g_return_val_if_fail (builder, QSQL_ERROR); qb = (struct QsqlBuilder *) builder; max = 0; qsql_be = qb->qsql_be; g_return_val_if_fail ((col_num < 4), QSQL_ERROR); g_return_val_if_fail (strings[2], QSQL_ERROR); frame = kvp_frame_new (); /* columnNames = fields strings = values [0]=kvp_id, [1]=guid, [2]=path, [3]=type, [4]=value get type from type_string */ type = sql_to_kvp_helper (strings[3]); if (type == 0) { PERR (" invalid type returned from kvp table"); return QSQL_ERROR; } /* use the type to make a KvpValue from value */ value = string_to_kvp_value (strings[4], type); if (!value) { PERR (" invalid KvpValue for type: %d", type); return QSQL_ERROR; } /* add the KvpValue to the frame at path */ kvp_frame_set_value (frame, strings[2], value); /* index the frame under the entity GUID */ g_hash_table_insert (qsql_be->kvp_table, strings[1], frame); /* index the guid under the kvp_id */ g_hash_table_insert (qsql_be->kvp_id, strings[0], strings[1]); errno = 0; max = strtol (strings[0], &tail, 0); if (errno == 0) { qsql_be->index = (max > qsql_be->index) ? max : qsql_be->index; } return SQLITE_OK; }
static void create_each_param | ( | QofParam * | param, |
gpointer | builder | ||
) | [static] |
create the sql for each parameter
Definition at line 447 of file qof-sqlite.c.
{ gchar *value; struct QsqlBuilder *qb; qb = (struct QsqlBuilder *) builder; GList *references; /* avoid creating database fields for calculated values */ if (!param->param_setfcn) return; /* avoid setting KVP even if a param_setfcn has been set because a QofSetterFunc for KVP is quite pointless. */ if (0 == safe_strcmp (param->param_type, QOF_TYPE_KVP)) return; references = qof_class_get_referenceList (qb->ent->e_type); if (g_list_find (references, param)) { QofEntity *e; e = param->param_getfcn (qb->ent, param); value = g_strnfill (GUID_ENCODING_LENGTH + 1, ' '); guid_to_string_buff (qof_entity_get_guid (e), value); PINFO (" ref=%p GUID=%s", e, value); } else value = qof_util_param_to_string (qb->ent, param); if (value) g_strescape (value, NULL); if (!value) value = g_strdup (""); if (!g_str_has_suffix (qb->sql_str, "(")) { gchar *val; val = g_strconcat (", \"", value, "\"", NULL); qb->sql_str = add_to_sql (qb->sql_str, val); g_free (val); } else { gchar *val; val = g_strconcat ("\"", value, "\"", NULL); qb->sql_str = add_to_sql (qb->sql_str, val); g_free (val); } }
static void create_event | ( | QofEntity * | ent, |
QofEventId | event_type, | ||
gpointer | handler_data, | ||
gpointer | event_data | ||
) | [static] |
receives QSQLiteBackend, passes on QsqlBuilder
Definition at line 548 of file qof-sqlite.c.
{ QofBackend *be; struct QsqlBuilder qb; QSQLiteBackend *qsql_be; gchar *gstr; KvpFrame *slots; qsql_be = (QSQLiteBackend *) handler_data; be = (QofBackend *) qsql_be; if (!ent) return; if (0 == safe_strcmp (ent->e_type, QOF_ID_BOOK)) return; if (!qof_class_is_registered (ent->e_type)) return; switch (event_type) { case QOF_EVENT_CREATE: { gchar *tmp; ENTER (" create:%s", ent->e_type); gstr = g_strnfill (GUID_ENCODING_LENGTH + 1, ' '); guid_to_string_buff (qof_instance_get_guid ((QofInstance *) ent), gstr); DEBUG (" guid=%s", gstr); qb.ent = ent; qb.sql_str = g_strdup_printf ("INSERT into %s (guid ", ent->e_type); qof_class_param_foreach (ent->e_type, create_param_list, &qb); tmp = g_strconcat (") VALUES (\"", gstr, "\" ", NULL); qb.sql_str = add_to_sql (qb.sql_str, tmp); g_free (tmp); qof_class_param_foreach (ent->e_type, create_each_param, &qb); qb.sql_str = add_to_sql (qb.sql_str, ");"); DEBUG (" sql_str=%s", qb.sql_str); if (sqlite_exec (qsql_be->sqliteh, qb.sql_str, NULL, &qb, &qsql_be->err) != SQLITE_OK) { qof_error_set_be (be, qsql_be->err_insert); qsql_be->error = TRUE; PERR (" error on create_event:%s", qsql_be->err); } else { ((QofInstance *) ent)->dirty = FALSE; qsql_be->error = FALSE; g_free (qb.sql_str); g_free (gstr); LEAVE (" "); break; } /* insert sqlite_kvp data */ slots = qof_instance_get_slots ((QofInstance *) ent); if (slots) { /* id, guid, path, type, value */ qb.sql_str = g_strconcat ("INSERT into ", QSQL_KVP_TABLE, " (kvp_id \"", gstr, "\", ", NULL); kvp_frame_for_each_slot (slots, kvpvalue_to_sql, &qb); qb.sql_str = add_to_sql (qb.sql_str, END_DB_VERSION); if (sqlite_exec (qsql_be->sqliteh, qb.sql_str, NULL, &qb, &qsql_be->err) != SQLITE_OK) { qof_error_set_be (be, qsql_be->err_insert); qsql_be->error = TRUE; PERR (" error on KVP create_event:%s", qsql_be->err); } else { ((QofInstance *) ent)->dirty = FALSE; qsql_be->error = FALSE; g_free (qb.sql_str); g_free (gstr); LEAVE (" "); break; } } g_free (qb.sql_str); g_free (gstr); LEAVE (" "); break; } default: break; } }
static void create_param_list | ( | QofParam * | param, |
gpointer | builder | ||
) | [static] |
list just the parameter names
Definition at line 419 of file qof-sqlite.c.
{ struct QsqlBuilder *qb; qb = (struct QsqlBuilder *) builder; /* avoid creating database fields for calculated values */ if (!param->param_setfcn) return; /* avoid setting KVP even if a param_setfcn has been set because a QofSetterFunc for KVP is quite pointless. */ if (0 == safe_strcmp (param->param_type, QOF_TYPE_KVP)) { PINFO (" kvp support tag"); return; } if (!g_str_has_suffix (qb->sql_str, "(")) { gchar *add; add = g_strconcat (", ", param->param_name, NULL); qb->sql_str = add_to_sql (qb->sql_str, add); g_free (add); } else qb->sql_str = add_to_sql (qb->sql_str, param->param_name); }
static void delete_event | ( | QofEntity * | ent, |
QofEventId | event_type, | ||
gpointer | handler_data, | ||
gpointer | event_data | ||
) | [static] |
use the new-style event handlers for insert and update insert runs after QOF_EVENT_CREATE delete runs before QOF_EVENT_DESTROY
Definition at line 499 of file qof-sqlite.c.
{ QofBackend *be; QSQLiteBackend *qsql_be; gchar *gstr, *sql_str; qsql_be = (QSQLiteBackend *) handler_data; be = (QofBackend *) qsql_be; if (!ent) return; if (0 == safe_strcmp (ent->e_type, QOF_ID_BOOK)) return; /* do not try to delete if only a QofObject has been loaded. */ if (!qof_class_is_registered (ent->e_type)) return; switch (event_type) { case QOF_EVENT_DESTROY: { ENTER (" %s do_free=%d", ent->e_type, ((QofInstance *) ent)->do_free); gstr = g_strnfill (GUID_ENCODING_LENGTH + 1, ' '); guid_to_string_buff (qof_entity_get_guid (ent), gstr); sql_str = g_strconcat ("DELETE from ", ent->e_type, " WHERE ", QOF_TYPE_GUID, "='", gstr, "';", NULL); DEBUG (" sql_str=%s", sql_str); if (sqlite_exec (qsql_be->sqliteh, sql_str, NULL, qsql_be, &qsql_be->err) != SQLITE_OK) { qof_error_set_be (be, qsql_be->err_delete); qsql_be->error = TRUE; LEAVE (" error on delete:%s", qsql_be->err); break; } /* SELECT kvp_id from QSQL_KVP_TABLE where guid = gstr */ LEAVE (" %d", event_type); qsql_be->error = FALSE; g_free (gstr); break; } default: break; } }
static QofIdTypeConst kvp_value_to_qof_type_helper | ( | KvpValueType | n | ) | [static] |
Map a KvpValue to a QofIdType.
Definition at line 145 of file qof-sqlite.c.
{ switch (n) { case KVP_TYPE_GINT64: { return QOF_TYPE_INT64; break; } case KVP_TYPE_DOUBLE: { return QOF_TYPE_DOUBLE; break; } case KVP_TYPE_NUMERIC: { return QOF_TYPE_NUMERIC; break; } case KVP_TYPE_STRING: { return QOF_TYPE_STRING; break; } case KVP_TYPE_GUID: { return QOF_TYPE_GUID; break; } #ifndef QOF_DISABLE_DEPRECATED case KVP_TYPE_TIMESPEC: { return QOF_TYPE_DATE; break; } #endif case KVP_TYPE_BOOLEAN: { return QOF_TYPE_BOOLEAN; break; } case KVP_TYPE_TIME: { return QOF_TYPE_TIME; break; } default: { return NULL; } } }
static void kvpvalue_to_sql | ( | const gchar * | key, |
KvpValue * | val, | ||
gpointer | builder | ||
) | [static] |
returns the VALUES for INSERT in pre-defined order
Definition at line 316 of file qof-sqlite.c.
{ QSQLiteBackend *qsql_be; struct QsqlBuilder *qb; KvpValueType n; gchar *full_path; full_path = NULL; ENTER (" "); qb = (struct QsqlBuilder *) builder; qsql_be = qb->qsql_be; g_return_if_fail (key && val && qsql_be); n = kvp_value_get_type (val); switch (n) { case KVP_TYPE_GINT64: case KVP_TYPE_DOUBLE: case KVP_TYPE_NUMERIC: case KVP_TYPE_STRING: case KVP_TYPE_GUID: case KVP_TYPE_TIME: case KVP_TYPE_BOOLEAN: #ifndef QOF_DISABLE_DEPRECATED case KVP_TYPE_TIMESPEC: #endif { /* ("kvp_id int primary key not null", "guid char(32)", "path mediumtext", "type mediumtext", "value text", */ qb->sql_str = g_strdup_printf (" kvp key=%s val=%s type=%s", key, kvp_value_to_bare_string (val), kvp_value_to_qof_type_helper (n)); DEBUG (" %s", qb->sql_str); qb->has_slots = TRUE; break; } case KVP_TYPE_FRAME: { kvp_frame_for_each_slot (kvp_value_get_frame (val), kvpvalue_to_sql, qb); break; } default: { PERR (" unsupported value = %d", kvp_value_get_type (val)); break; } } LEAVE (" %s", qb->sql_str); }
static QofBackend* qsql_backend_new | ( | void | ) | [static] |
Starts the backend and creates the context.
Definition at line 1446 of file qof-sqlite.c.
{ QSQLiteBackend *qsql_be; QofBackend *be; ENTER (" "); qsql_be = g_new0 (QSQLiteBackend, 1); be = (QofBackend *) qsql_be; qof_backend_init (be); qsql_be->kvp_table = g_hash_table_new (g_str_hash, g_str_equal); qsql_be->kvp_id = g_hash_table_new (g_str_hash, g_str_equal); qsql_be->dbversion = QOF_OBJECT_VERSION; qsql_be->stm_type = SQL_NONE; qsql_be->err_delete = qof_error_register (_("Unable to delete record."), FALSE); qsql_be->err_create = qof_error_register (_("Unable to create record."), FALSE); qsql_be->err_insert = qof_error_register (_("Unable to insert a new record."), FALSE); qsql_be->err_update = qof_error_register (_("Unable to update existing record."), FALSE); be->session_begin = qsqlite_session_begin; be->session_end = qsqlite_session_end; be->destroy_backend = qsqlite_destroy_backend; be->load = qsqlite_db_load; be->save_may_clobber_data = NULL; /* begin: create an empty entity if none exists, even if events are suspended. */ be->begin = qsql_create; /* commit: write to sqlite, commit undo record. */ be->commit = qsql_modify; be->rollback = NULL; /* would need a QofQuery back to QofSqlQuery conversion. */ be->compile_query = NULL; /* unused */ be->free_query = NULL; be->run_query = NULL; be->counter = NULL; /* The QOF SQLite backend is not multi-user - all QOF users are the same. */ be->events_pending = NULL; be->process_events = NULL; be->sync = qsqlite_write_db; be->load_config = NULL; be->get_config = NULL; LEAVE (" "); return be; }
static void qsql_class_foreach | ( | QofObject * | obj, |
gpointer | data | ||
) | [static] |
receives QSQLiteBackend from QofBackend
Definition at line 1168 of file qof-sqlite.c.
{ struct QsqlBuilder qb; QSQLiteBackend *qsql_be; QofBackend *be; qsql_be = (QSQLiteBackend *) data; be = (QofBackend *) qsql_be; qb.qsql_be = qsql_be; qb.e_type = obj->e_type; ENTER (" obj_type=%s", qb.e_type); switch (qsql_be->stm_type) { case SQL_NONE: case SQL_INSERT: case SQL_DELETE: case SQL_UPDATE: { break; } case SQL_CREATE: { /* KVP is handled separately */ qb.sql_str = g_strdup_printf ("CREATE TABLE %s (", obj->e_type); qof_class_param_foreach (obj->e_type, string_param_foreach, &qb); qb.sql_str = add_to_sql (qb.sql_str, END_DB_VERSION); if (sqlite_exec (qsql_be->sqliteh, qb.sql_str, NULL, NULL, &qsql_be->err) != SQLITE_OK) { qof_error_set_be (be, qsql_be->err_create); qsql_be->error = TRUE; PERR (" error on SQL_CREATE:%s", qsql_be->err); } g_free (qb.sql_str); break; } case SQL_LOAD: { qb.sql_str = g_strdup_printf ("SELECT * FROM %s;", obj->e_type); PINFO (" sql=%s", qb.sql_str); if (sqlite_exec (qsql_be->sqliteh, qb.sql_str, record_foreach, &qb, &qsql_be->err) != SQLITE_OK) { qsql_be->error = TRUE; PERR (" error on SQL_LOAD:%s", qsql_be->err); } break; } case SQL_WRITE: { if (!qof_book_not_saved (qsql_be->book)) break; qof_object_foreach (obj->e_type, qsql_be->book, check_state, &qb); break; } } LEAVE (" "); }
static void qsql_load_kvp | ( | QSQLiteBackend * | qsql_be | ) | [static] |
only call once per book
Definition at line 1127 of file qof-sqlite.c.
{ struct QsqlBuilder qb; QofBackend *be; gint sq_code; g_return_if_fail (qsql_be); sq_code = SQLITE_OK; be = (QofBackend *) qsql_be; qb.sql_str = g_strdup_printf ("SELECT kvp_id from %s;", QSQL_KVP_TABLE); sq_code = sqlite_exec (qsql_be->sqliteh, qb.sql_str, build_kvp_table, &qb, &qsql_be->err); /* catch older files without a sqlite_kvp table */ if (sq_code == SQLITE_ERROR) { g_free (qb.sql_str); qb.sql_str = g_strdup_printf ("CREATE TABLE %s (%s, %s, %s, %s, %s, %s", QSQL_KVP_TABLE, "kvp_id int primary key not null", "guid char(32)", "path mediumtext", "type mediumtext", "value text", END_DB_VERSION); PINFO (" creating kvp table. sql=%s", qb.sql_str); if (sqlite_exec (qsql_be->sqliteh, qb.sql_str, record_foreach, &qb, &qsql_be->err) != SQLITE_OK) { qsql_be->error = TRUE; PERR (" unable to create kvp table:%s", qsql_be->err); } } else if (sq_code != SQLITE_OK) { qof_error_set_be (be, qsql_be->err_create); qsql_be->error = TRUE; PERR (" error on KVP select:%s:%s:%d", qb.sql_str, qsql_be->err, sq_code); } g_free (qb.sql_str); }
static gint record_foreach | ( | gpointer | builder, |
gint | col_num, | ||
gchar ** | strings, | ||
gchar ** | columnNames | ||
) | [static] |
Definition at line 713 of file qof-sqlite.c.
{ QSQLiteBackend *qsql_be; struct QsqlBuilder *qb; const QofParam *param; QofInstance *inst; QofEntity *ent; gint i; g_return_val_if_fail (builder, QSQL_ERROR); qb = (struct QsqlBuilder *) builder; qsql_be = qb->qsql_be; qof_event_suspend (); inst = (QofInstance *) qof_object_new_instance (qb->e_type, qsql_be->book); ent = &inst->entity; for (i = 0; i < col_num; i++) { /* get param and set as string */ param = qof_class_get_parameter (qb->e_type, columnNames[i]); if (!param) continue; /* set the inst->param entry */ inst->param = param; if (0 == safe_strcmp (columnNames[i], QOF_TYPE_GUID)) { GUID *guid; guid = guid_malloc (); if (!string_to_guid (strings[i], guid)) { DEBUG (" set guid failed:%s", strings[i]); return QSQL_ERROR; } qof_entity_set_guid (ent, guid); } if (strings[i]) qof_util_param_set_string (ent, param, strings[i]); } qof_event_resume (); return SQLITE_OK; }
static KvpValueType sql_to_kvp_helper | ( | const gchar * | type_string | ) | [static] |
Definition at line 200 of file qof-sqlite.c.
{ if (0 == safe_strcmp (QOF_TYPE_INT64, type_string)) return KVP_TYPE_GINT64; if (0 == safe_strcmp (QOF_TYPE_DOUBLE, type_string)) return KVP_TYPE_DOUBLE; if (0 == safe_strcmp (QOF_TYPE_NUMERIC, type_string)) return KVP_TYPE_NUMERIC; if (0 == safe_strcmp (QOF_TYPE_STRING, type_string)) return KVP_TYPE_STRING; if (0 == safe_strcmp (QOF_TYPE_GUID, type_string)) return KVP_TYPE_GUID; #ifndef QOF_DISABLE_DEPRECATED if (0 == safe_strcmp (QOF_TYPE_DATE, type_string)) return KVP_TYPE_TIMESPEC; #endif if (0 == safe_strcmp (QOF_TYPE_TIME, type_string)) return KVP_TYPE_TIME; return 0; }
static gchar* string_param_to_sql | ( | QofParam * | param | ) | [static] |
< secondary collections are used for one-to-many references between entities and are implemented using QofCollection. These are NOT the same as the main collections in the QofBook. -# Each QofCollection contains one or many entities - *all* of a single type. -# The entity type within the collection can be determined at run time. -# Easy conversions to GList or whatever in the param_setfcn handler. -# Each parameter can have its own collection. -# Each entity can have a different *type* of collection to its siblings, provided that it is acceptable to the set function. -# Each object decides which types are acceptable for which parameter in the set functions. This is then part of the API for that object. QOF_TYPE_COLLECT has two functions, both related to one-to-many links: - Represent a reference between 2 entities with a list of acceptable types. (one object linked to many types of single entities) - Represent a reference between one entity and many entities of another type. (one object linked to many entities of a single type.) If the set function can handle it, it could also be used for true one-to-many links: one object linked to many entities of many types. n.b. Always subject to each collection holding only one type at runtime. (otherwise use books).
Definition at line 369 of file qof-sqlite.c.
{ /* Handle the entity GUID. Ensure that reference GUIDs must not also try to be primary keys and can be NULL. */ if ((0 == safe_strcmp (param->param_type, QOF_TYPE_GUID)) && (0 == safe_strcmp (param->param_name, QOF_PARAM_GUID))) return g_strdup_printf (" %s char(32) primary key not null", param->param_name); if (0 == safe_strcmp (param->param_type, QOF_TYPE_GUID)) return g_strdup_printf (" %s char(32)", param->param_name); /* avoid creating database fields for calculated values */ if (!param->param_setfcn) return NULL; if (0 == safe_strcmp (param->param_type, QOF_TYPE_STRING)) return g_strdup_printf (" %s mediumtext", param->param_name); if (0 == safe_strcmp (param->param_type, QOF_TYPE_BOOLEAN)) return g_strdup_printf (" %s int", param->param_name); if ((0 == safe_strcmp (param->param_type, QOF_TYPE_NUMERIC)) || (0 == safe_strcmp (param->param_type, QOF_TYPE_DOUBLE)) || (0 == safe_strcmp (param->param_type, QOF_TYPE_DEBCRED))) { return g_strdup_printf (" %s text", param->param_name); } if (0 == safe_strcmp (param->param_type, QOF_TYPE_INT32)) return g_strdup_printf (" %s int", param->param_name); #ifndef QOF_DISABLE_DEPRECATED if ((0 == safe_strcmp (param->param_type, QOF_TYPE_DATE)) || (0 == safe_strcmp (param->param_type, QOF_TYPE_TIME))) #else if (0 == safe_strcmp (param->param_type, QOF_TYPE_TIME)) #endif return g_strdup_printf (" %s datetime", param->param_name); if (0 == safe_strcmp (param->param_type, QOF_TYPE_CHAR)) return g_strdup_printf (" %s char(1)", param->param_name); /* kvp data is stored separately - actually this is really a no-op because entities do not need a param_setfcn for kvp data. */ if (0 == safe_strcmp (param->param_type, QOF_TYPE_KVP)) return g_strdup (""); if (0 == safe_strcmp (param->param_type, QOF_TYPE_COLLECT)) return g_strdup_printf (" %s char(32)", param->param_name); /* catch references */ return g_strdup_printf (" %s char(32)", param->param_name); }
KvpValue* string_to_kvp_value | ( | const gchar * | content, |
KvpValueType | type | ||
) |
Convert a string value into KvpValue.
Definition at line 223 of file qof-sqlite.c.
{ gchar *tail; gint64 cm_i64; gdouble cm_double; QofNumeric cm_numeric; GUID *cm_guid; #ifndef QOF_DISABLE_DEPRECATED struct tm kvp_time; time_t kvp_time_t; Timespec cm_date; #endif switch (type) { case KVP_TYPE_GINT64: { errno = 0; cm_i64 = strtoll (content, &tail, 0); if (errno == 0) { return kvp_value_new_gint64 (cm_i64); } break; } case KVP_TYPE_DOUBLE: { errno = 0; cm_double = strtod (content, &tail); if (errno == 0) return kvp_value_new_double (cm_double); break; } case KVP_TYPE_NUMERIC: { qof_numeric_from_string (content, &cm_numeric); return kvp_value_new_numeric (cm_numeric); break; } case KVP_TYPE_STRING: { return kvp_value_new_string (content); break; } case KVP_TYPE_GUID: { cm_guid = g_new0 (GUID, 1); if (TRUE == string_to_guid (content, cm_guid)) return kvp_value_new_guid (cm_guid); break; } case KVP_TYPE_TIME: { QofDate *qd; QofTime *qt; KvpValue *retval; qd = qof_date_parse (content, QOF_DATE_FORMAT_UTC); if (qd) { qt = qof_date_to_qtime (qd); retval = kvp_value_new_time (qt); qof_date_free (qd); qof_time_free (qt); return retval; } else PERR (" failed to parse date"); } #ifndef QOF_DISABLE_DEPRECATED case KVP_TYPE_TIMESPEC: { strptime (content, QOF_UTC_DATE_FORMAT, &kvp_time); kvp_time_t = mktime (&kvp_time); timespecFromTime_t (&cm_date, kvp_time_t); return kvp_value_new_timespec (cm_date); break; } #endif case KVP_TYPE_BOOLEAN: { gboolean val; val = qof_util_bool_to_int (content); return kvp_value_new_boolean (val); } default: break; } return NULL; }