QOF Command Line Interface
[Query Object Framework]


Data Structures

struct  QofMain_s
 The qof-main context struct. More...

Files

file  qof-main.c
 Common functions for the QOF external framework.
file  qof-main.h
 Common functions for the QOF external framework.

Defines

#define _GNU_SOURCE
#define MAX_LINE   79
#define ERR_INDENT   strlen(PACKAGE) + 2
 Indent error messages as paragraphs.
#define QOF_DATE_STRING_LENGTH   MAX_DATE_LENGTH
#define QOF_MAIN_CLI   "QOF-mod-command-line"
#define CATEGORY_NAME   "category"
 Category name.
#define QSF_COMPRESS   "compression_level"
#define QSF_ENCODING   "encoding_string"
#define QSF_DATE_CONVERT   "convert_date_to_time"
#define QOF_SQL_SUPPORTED   "^SELECT|INSERT"
#define QOF_CLI_OPTIONS
 Common QOF CLI options.
#define QOF_MAIN_OP
#define QOF_OP_VARS
#define QOF_OP_INIT

Typedefs

typedef struct QofMain_s QofMainContext
 The qof-main context struct.

Functions

void qof_main_wrap_line (FILE *fp, gint indent, const gchar *template_str,...) __attribute__((format(printf
 Wrap long lines in popt-style.
static void qof_main_run_sql (QofMainContext *context)
static void qof_main_run_query (QofMainContext *context)
void qof_main_free (QofMainContext *context)
static void find_param_cb (QofParam *param, gpointer user_data)
static void build_database_list (QofIdTypeConst obj_type, QofMainContext *context)
static void select_cb (QofObject *obj, gpointer data)
void qof_main_moderate_query (QofMainContext *context)
 Assemble the components of the query.
static void option_cb (QofBackendOption *option, gpointer data)
void qof_mod_compression (gint64 gz_level, QofMainContext *context)
void qof_mod_encoding (const gchar *encoding, QofMainContext *context)
void qof_mod_convert_deprecated (gint64 convert, QofMainContext *context)
void qof_cmd_xmlfile (QofMainContext *context)
static void qof_main_list (QofObject *obj, gpointer G_GNUC_UNUSED data)
void qof_main_select (QofMainContext *context)
void qof_cmd_list (void)
 Lists all databases supported by the current QOF framework.
static void explain_cb (QofParam *param, gpointer G_GNUC_UNUSED user_data)
void qof_cmd_explain (QofMainContext *context)
void qof_mod_category (const gchar *category, QofMainContext *data)
 Shorthand to only query objects that are set to the specified category.
glong qof_mod_get_local_offset (void)
 Get the gmt_off offset for this locale.
void qof_mod_database (const gchar *database, QofMainContext *data)
 Shorthand to only query objects within one specific supported database.
void qof_mod_time (const gchar *date_time, QofMainContext *data)
 Shorthand to only query objects that contain the specified date.
void qof_mod_exclude (const gchar *exclude, QofMainContext *data)
 Shorthand to exclude a supported database from the query.
void qof_mod_sql (const gchar *sql_query, QofMainContext *data)
 Specify a SQL query on the command line.
void qof_mod_sql_file (const gchar *sql_file, QofMainContext *data)
 Specify one or more SQL queries contained in a file.
void qof_mod_write (const gchar *write_file, QofMainContext *data)
 Write the results of any query to the file.
void qof_main_show_error (QofSession *session)
 Output error messages from QOF.
GSList * qof_main_get_param_list (QofIdTypeConst object_type, QofType param_type)
 List of all parameters for this object of one QOF type.

Variables

static QofLogModule log_module = "QOF-mod-command-line"

Detailed Description

Includes common functions for all QOF CLI programs and provides generic functions to implement command line and interactive shell options.

QOF provides an outline CLI that is easily patched from the qof-generator project to make it easier to keep various QOF projects updated.

This CLI is easily extended to support your own functions and options and includes macros to help you keep up to date with changes in main QOF options. It is recommended that you do not edit this file, instead please feed patches back to the QOF-devel mailing list at http://lists.sourceforge.net/mailman/listinfo/qof-devel so that other projects can be updated.


Define Documentation

#define CATEGORY_NAME   "category"

Category name.

The name of the parameter that holds the category of the entity.

Many CLI data sources categorise data by user-editable category strings. If your program does not, simply implement a modified QOF_CLI_OPTIONS in your code without the category option:

{"category", 'c', POPT_ARG_STRING, &category, qof_op_category,
_("Shorthand to only query objects that are set to the specified category."),
"string"},

Definition at line 118 of file qof-main.h.

#define QOF_CLI_OPTIONS

Common QOF CLI options.

These are definitions for popt support in the CLI. Every program's popt table should start with QOF_CLI_OPTIONS or a replacement to insert the standard options into it. Also enables autohelp. End your popt option list with POPT_TABLEEND. If you want to remove any of these options, simply copy QOF_CLI_OPTIONS into a macro of your own and remove the options you do not need.

Definition at line 419 of file qof-main.h.

#define QOF_DATE_STRING_LENGTH   MAX_DATE_LENGTH

Maximum length of the UTC timestamp used by QSF

QOF_UTC_DATE_FORMAT "%Y-%m-%dT%H:%M:%SZ"

Definition at line 100 of file qof-main.h.

#define QOF_MAIN_CLI   "QOF-mod-command-line"

Debug module for qof-main

Definition at line 103 of file qof-main.h.

#define QOF_MAIN_OP

Value:

_(qof_op_noop, = 0) \
        _(qof_op_list,)     \
        _(qof_op_xmlfile,)  \
        _(qof_op_category,) \
        _(qof_op_database,) \
        _(qof_op_time,) \
        _(qof_op_exclude,)  \
        _(qof_op_sql,)      \
        _(qof_op_sql_file,) \
        _(qof_op_write, )   \
        _(qof_op_explain,)  \
        _(qof_op_vers,)     \
        _(qof_op_compress,) \
        _(qof_op_debug,)
use only if you have no extended options, otherwise use as a template.

Definition at line 456 of file qof-main.h.

#define QOF_OP_INIT

Value:

exclude = NULL;    \
        category = NULL;   \
        database = NULL;   \
        sql_file = NULL;   \
        write_file = NULL; \
        sql_query = NULL;  \
        filename = NULL;
initialise the standard QOF CLI option variables.

A simple convenience macro.

Definition at line 485 of file qof-main.h.

#define QOF_OP_VARS

Value:

const gchar *exclude,  *date_time,  *category,  *database; \
        const gchar *sql_file, *write_file, *sql_query, *filename;
Define the variables for the standard QOF CLI options.

If you remove any QOF CLI options, ensure you also remove the option variable and it's initialiser.

Definition at line 477 of file qof-main.h.

#define QOF_SQL_SUPPORTED   "^SELECT|INSERT"

The SQL commands supported by QOF

A regular expression used to exclude unsupported commands from SQL files. Anything that does not match the expression will be silently ignored. This allows genuine SQL dump files to be parsed without errors.

A QOF object is similar to a definition of a SQL table.
A QOF entity is similar to an instance of a SQL record.
A QOF parameter is similar to data in a SQL field.

Certain SQL commands have no QOF equivalent and should always be ignored silently:

  • ALTER (the object parameters cannot be changed at runtime)
  • CREATE (new tables - new objects - cannot be created at runtime)
  • DROP (an object cannot be "de-registered" without re-compiling)
  • FLUSH (QOF has no permissions system)
  • GRANT
  • KILL
  • LOCK
  • OPTIMIZE
  • REVOKE
  • USE (QOF only has one database, itself.)

Definition at line 159 of file qof-main.h.

Referenced by qof_mod_sql_file().

#define QSF_COMPRESS   "compression_level"

backend configuration index string for QSF

The identifier for the configuration option within QSF supported by the CLI. Matches the QofBackendOption->option_name in the KvpFrame holding the options.

Definition at line 127 of file qof-main.h.

#define QSF_DATE_CONVERT   "convert_date_to_time"

convert deprecated date fields into times.

Definition at line 133 of file qof-main.h.

#define QSF_ENCODING   "encoding_string"

backend configuration encoding string

Definition at line 130 of file qof-main.h.


Typedef Documentation

typedef struct QofMain_s QofMainContext

The qof-main context struct.

Intended as a core type for QOF-based CLI programs, wrap your own context struct around qof_main_context


Function Documentation

void qof_cmd_explain ( QofMainContext context  ) 

Print a list of available parameters for a database.

Used with qof_mod_database to print a list of QofParam for the QofObject set in context->database.

Definition at line 447 of file qof-main.c.

References QofMain_s::database, and QofMain_s::error.

00448 {
00449         if (context->error)
00450                 return;
00451         fprintf (stdout, _("\nParameters of the %s database:\n\n"),
00452                 context->database);
00453         qof_class_param_foreach (context->database, explain_cb, NULL);
00454         fprintf (stdout, _("\nThank you for using %s\n\n"), PACKAGE);
00455 }

void qof_cmd_list ( void   ) 

Lists all databases supported by the current QOF framework.

Prints the name and description for each object type registered with this instance of QOF. No options are used.

Definition at line 419 of file qof-main.c.

References qof_main_wrap_line().

00420 {
00421         qof_main_wrap_line (stdout, 0,
00422         /* Translators: This line is wrapped by the program - 
00423         please make sure you do NOT add line endings here. */
00424                 _("\n%s: You can use the supported database names with '%s -d' "
00425                         "and in SQL queries (as the table name) with '%s -s|f'. "
00426                         "Descriptions are shown only for readability.\n"),
00427                 PACKAGE, PACKAGE, PACKAGE);
00428         fprintf (stdout, "%-20s%-20s\n", _("Name"), _("Description"));
00429         qof_object_foreach_type (qof_main_list, NULL);
00430         qof_main_wrap_line (stdout, 0,
00431         /* Translators: This line is wrapped by the program -
00432         please make sure you do NOT add line endings here. */
00433                 _("\nUse '%s -d <database> --explain' to see the list of fields "
00434                         "within any supported database."), PACKAGE);
00435         fprintf (stdout, _("\nThank you for using %s\n\n"), PACKAGE);
00436 }

void qof_cmd_xmlfile ( QofMainContext context  ) 

query the QSF XML data

Definition at line 357 of file qof-main.c.

References QofMain_s::database, QofMain_s::encoding, ERR_INDENT, QofMain_s::exclude, QofMain_s::export_session, QofMain_s::filename, QofMain_s::gz_level, QofMain_s::input_session, qof_main_moderate_query(), qof_main_show_error(), qof_main_wrap_line(), qof_mod_compression(), qof_mod_encoding(), and QofMain_s::write_file.

00358 {
00359         QofSession *input_session, *export_session;
00360 
00361         ENTER (" ");
00362         input_session = context->input_session;
00363         if (0 == safe_strcmp (context->exclude, context->database)
00364                 && (context->exclude != NULL))
00365         {
00366                 qof_main_wrap_line (stderr, ERR_INDENT,
00367                 /* Translators: This line is wrapped by the program - 
00368                 please make sure you do NOT add line endings here. */
00369                         _("%s: Error: Cannot exclude database \"%s\" with option -e "
00370                                 "because option -d is set to include the database: \"%s\". "
00371                                 "Use the \'-l\' command to see the full list of supported "
00372                                 "databases.\n"), PACKAGE, context->exclude,
00373                         context->database);
00374                 qof_session_end (input_session);
00375                 LEAVE (" conflicting options");
00376                 return;
00377         }
00378         qof_session_begin (input_session, context->filename, TRUE, FALSE);
00379         qof_main_show_error (input_session);
00380         if (0 != safe_strcmp (QOF_STDOUT, context->filename))
00381                 qof_session_load (input_session, NULL);
00382         qof_main_show_error (input_session);
00383         export_session = qof_session_new ();
00384         context->export_session = export_session;
00385         if (context->write_file)
00386         {
00387                 qof_session_begin (export_session, context->write_file, TRUE,
00388                         TRUE);
00389                 qof_mod_compression (context->gz_level, context);
00390         }
00391         else
00392                 qof_session_begin (export_session, QOF_STDOUT, TRUE, FALSE);
00393         qof_main_show_error (export_session);
00394         /* ensure encoding value is set in the new export_session */
00395         qof_mod_encoding (context->encoding, context);
00396         qof_main_moderate_query (context);
00397         qof_session_save (export_session, NULL);
00398         qof_main_show_error (export_session);
00399         qof_main_show_error (input_session);
00400         qof_session_end (input_session);
00401         qof_session_end (export_session);
00402         LEAVE (" ");
00403 }

void qof_main_free ( QofMainContext context  ) 

Free qof_main_context values when work is done.

Definition at line 136 of file qof-main.c.

References QofMain_s::category, QofMain_s::database, QofMain_s::filename, QofMain_s::sql_file, and QofMain_s::write_file.

Referenced by gpe_expense_close().

00137 {
00138         g_free (context->filename);
00139         g_free (context->write_file);
00140         g_free (context->sql_file);
00141         g_free (context->database);
00142         g_free (context->category);
00143 }

GSList* qof_main_get_param_list ( QofIdTypeConst  object_type,
QofType  param_type 
)

List of all parameters for this object of one QOF type.

Return a GSList of all parameters of this object that are a particular QOF type, QOF_TYPE_STRING, QOF_TYPE_BOOLEAN etc.

The returned GSList should be freed by the caller.

Note:
The return list is a singly linked list - GSList - not the doubly-linked list - GList - returned by qof_class_get_referenceList.
Parameters:
object_type object->e_type for the relevant object.
param_type The type of parameter to match, QOF_TYPE_STRING etc.
Returns:
GSList of all matching parameters or NULL if none exist.

void qof_main_moderate_query ( QofMainContext context  ) 

Assemble the components of the query.

If any SQL statements are found, run separately from any -c, -d or -t options.

All queries are additive: Successive queries add more entities to the result set but no entity is set more than once.

Definition at line 224 of file qof-main.c.

References QofMain_s::database, QofMain_s::exclude, QofMain_s::query, QofMain_s::sql_list, and QofMain_s::sql_str.

Referenced by qof_cmd_xmlfile().

00225 {
00226         GSList *date_param_list, *category_param_list;
00227         gboolean all;
00228 
00229         ENTER (" ");
00230         all = TRUE;
00231         context->query = qof_query_create ();
00232         date_param_list = NULL;
00233         category_param_list = NULL;
00234         while (context->sql_list)
00235         {
00236                 PINFO ("running sql_list");
00237                 context->sql_str = g_strdup (context->sql_list->data);
00238                 qof_main_run_sql (context);
00239                 qof_main_run_query (context);
00240                 if (context->query)
00241                         qof_query_clear (context->query);
00242                 g_free (context->sql_str);
00243                 context->sql_str = NULL;
00244                 all = FALSE;
00245                 context->sql_list = g_list_next (context->sql_list);
00246         }
00247         if (0 < g_list_length (context->sql_list))
00248         {
00249                 context->sql_str = NULL;
00250                 g_list_free (context->sql_list);
00251                 all = FALSE;
00252         }
00253         if (context->sql_str != NULL)
00254         {
00255                 PINFO ("running sql_str");
00256                 qof_main_run_sql (context);
00257                 qof_main_run_query (context);
00258                 if (context->query)
00259                         qof_query_clear (context->query);
00260                 all = FALSE;
00261         }
00262         if ((context->exclude != NULL)
00263                 && (qof_class_is_registered (context->exclude)))
00264         {
00265                 qof_object_foreach_type (select_cb, context);
00266                 all = FALSE;
00267         }
00268         if ((context->database != NULL)
00269                 && (qof_class_is_registered (context->database)))
00270         {
00271                 build_database_list (context->database, context);
00272                 all = FALSE;
00273         }
00274         if (all == TRUE)
00275                 qof_object_foreach_type (select_cb, context);
00276         LEAVE (" ");
00277 }

void qof_main_show_error ( QofSession *  session  ) 

Output error messages from QOF.

QOF will set errors in the QofSession. The application determines how to output those messages and for the CLI, this will be to stderr. Not all these messages are implemented in any one QOF CLI.

Parameters:
session Any current session.

Definition at line 603 of file qof-main.c.

References ERR_INDENT, and qof_main_wrap_line().

Referenced by qof_cmd_xmlfile().

00604 {
00605         const gchar *fmt;
00606 
00607         if (qof_error_check (session))
00608         {
00609                 fmt = "%s: %s\n";
00610                 qof_main_wrap_line (stderr, ERR_INDENT, fmt, PACKAGE,
00611                         qof_error_get_message (session));
00612         }
00613 }

void qof_main_wrap_line ( FILE *  fp,
gint  indent,
const gchar *  template_str,
  ... 
)

Wrap long lines in popt-style.

Defaults to a line width of 79 characters. Indents lines following the first according to the value of indent.

Parameters:
fp A file stream, including stdout or stderr.
indent The number of characters to indent from the left. Values over or equal to 79 or less than zero are adjusted.
template_str String to be wrapped, containing positional parameters, as specified in the Single Unix Specification. Can be translated but should not contain newline characters except at the beginning or end of the message.
Note:
Once wrapped, the line has a newline appended. Adding a newline to the incoming string will generate a blank line.

Definition at line 56 of file qof-main.c.

Referenced by qof_cmd_list(), qof_cmd_xmlfile(), qof_main_show_error(), and qof_mod_sql_file().

00058 {
00059         gint line_length, msg_length;
00060         va_list wraps;
00061         gchar *message;
00062 
00063         line_length = MAX_LINE;
00064         /* note the modulus. Don't use CLAMP here */
00065         /* indent != line_length or particularly close to it. */
00066         indent = indent >= line_length ? indent % line_length : indent;
00067         indent = indent < 0 ? 0 : indent;
00068         message = NULL;
00069         g_return_if_fail (template);
00070         va_start (wraps, template);
00071         message = g_strdup_vprintf (template, wraps);
00072         va_end (wraps);
00073         g_return_if_fail (message);
00074         msg_length = strlen (message);
00075         while (msg_length > line_length)
00076         {
00077                 gchar *chunk;
00078                 gchar format[16];
00079 
00080                 chunk = message + line_length - 1;
00081                 while (chunk > message && !g_ascii_isspace (*chunk))
00082                         chunk--;
00083                 if (chunk == message)
00084                         break;                          /* give up */
00085                 while (chunk > (message + 1) && g_ascii_isspace (*chunk))
00086                         chunk--;
00087                 chunk++;
00088                 g_sprintf (format, "%%.%ds\n%%%ds", (gint) (chunk - message),
00089                         indent);
00090                 g_fprintf (fp, format, message, "");
00091                 message = chunk;
00092                 while (g_ascii_isspace (*message) && *message)
00093                         message++;
00094                 msg_length = strlen (message);
00095                 if (line_length == MAX_LINE)
00096                         line_length -= indent;
00097         }
00098         if (msg_length)
00099                 g_fprintf (fp, "%s\n", message);
00100 }

void qof_mod_category ( const gchar *  category,
QofMainContext data 
)

Shorthand to only query objects that are set to the specified category.

Modifies the QOF query to only query objects that are set to category.

Definition at line 458 of file qof-main.c.

References QofMain_s::category.

00459 {
00460         data->category = g_strdup (category);
00461 }

void qof_mod_compression ( gint64  gz_level,
QofMainContext context 
)

Pass the requested compression to QSF

Parameters:
gz_level Integer between 0 and 9, 9 highest compression, 0 for none.
context The QofMain context.

Definition at line 301 of file qof-main.c.

References QofMain_s::export_session, and QofMain_s::gz_level.

Referenced by qof_cmd_xmlfile().

00302 {
00303         KvpFrame *be_config;
00304         QofBook *book;
00305         QofBackend *be;
00306 
00307         ENTER (" compression=%" G_GINT64_FORMAT, gz_level);
00308         if ((gz_level > 0) && (gz_level <= 9))
00309         {
00310                 book = qof_session_get_book (context->export_session);
00311                 be = qof_book_get_backend (book);
00312                 be_config = qof_backend_get_config (be);
00313                 context->gz_level = gz_level;
00314                 qof_backend_option_foreach (be_config, option_cb, context);
00315                 qof_backend_load_config (be, be_config);
00316         }
00317         LEAVE (" ");
00318 }

void qof_mod_convert_deprecated ( gint64  convert,
QofMainContext context 
)

configure handling of deprecated date fields.

Definition at line 338 of file qof-main.c.

References QofMain_s::convert, and QofMain_s::export_session.

00339 {
00340         KvpFrame *be_config;
00341         QofBook *book;
00342         QofBackend *be;
00343         gboolean set;
00344 
00345         set = (convert == 0) ? FALSE : TRUE;
00346         ENTER (" convert deprecated date values? %i No if 0.", set);
00347         book = qof_session_get_book (context->export_session);
00348         be = qof_book_get_backend (book);
00349         be_config = qof_backend_get_config (be);
00350         context->convert = convert;
00351         qof_backend_option_foreach (be_config, option_cb, context);
00352         qof_backend_load_config (be, be_config);
00353         LEAVE (" ");
00354 }

void qof_mod_database ( const gchar *  database,
QofMainContext data 
)

Shorthand to only query objects within one specific supported database.

Used to only query objects within the specified database.

Definition at line 478 of file qof-main.c.

References QofMain_s::database.

00479 {
00480         if (qof_class_is_registered (database))
00481                 data->database = g_strdup (database);
00482 }

void qof_mod_encoding ( const gchar *  encoding,
QofMainContext context 
)

Pass an encoding string to the backend.

Definition at line 321 of file qof-main.c.

References QofMain_s::encoding, and QofMain_s::export_session.

Referenced by qof_cmd_xmlfile().

00322 {
00323         KvpFrame *be_config;
00324         QofBook *book;
00325         QofBackend *be;
00326 
00327         ENTER (" encode to %s", encoding);
00328         book = qof_session_get_book (context->export_session);
00329         be = qof_book_get_backend (book);
00330         be_config = qof_backend_get_config (be);
00331         context->encoding = encoding;
00332         qof_backend_option_foreach (be_config, option_cb, context);
00333         qof_backend_load_config (be, be_config);
00334         LEAVE (" ");
00335 }

void qof_mod_exclude ( const gchar *  exclude,
QofMainContext data 
)

Shorthand to exclude a supported database from the query.

Excludes the (single) specified database from the query.

Definition at line 533 of file qof-main.c.

References QofMain_s::exclude.

00534 {
00535         if (qof_class_is_registered (exclude))
00536                 data->exclude = g_strdup (exclude);
00537 }

glong qof_mod_get_local_offset ( void   ) 

Get the gmt_off offset for this locale.

User specified strings can be assumed to be in localtime, but values are stored as UTC. This offset allows the application to modify the minimum and maximum time settings for queries so that the user gets the expected results.

If the timezone is +0100 and the date is 24th July 2006, values could be stored as 11pm on 23rd July 2006 UTC. qof_mod_get_local_offset returns -86400. Add this value to the minimum and maximum time passed to the query to ensure queries select expected timeframe: 2006-07-23T23:00:00Z to 2006-07-24T22:59:59Z.

Returns:
the number of seconds difference between localtime and UTC.

Definition at line 464 of file qof-main.c.

Referenced by qof_mod_time().

00465 {
00466         glong local_offset;
00467         struct tm local;
00468         time_t now;
00469 
00470         local_offset = 0; /* UTC */
00471         now = time (NULL);
00472         local = *localtime_r (&now, &local);
00473         local_offset -= local.tm_gmtoff;
00474         return local_offset;
00475 }

void qof_mod_sql ( const gchar *  sql_query,
QofMainContext data 
)

Specify a SQL query on the command line.

For SELECT, the returned list is a list of all of the instances of 'SomeObj' that match the query. The 'SORT' term is optional. The 'WHERE' term is optional; but if you don't include 'WHERE', you will get a list of all of the object instances. The Boolean operations 'AND' and 'OR' together with parenthesis can be used to construct arbitrarily nested predicates.

For INSERT, the returned list is a list containing the newly created instance of 'SomeObj'.

Date queries handle full date and time strings, using the format exported by the QSF backend. To query dates and times, convert user input into UTC time using qof_date_print and QOF_DATE_FORMAT_UTC

If the param is a KVP frame, then we use a special markup to indicate frame values. The markup should look like /some/kvp/path:value. Thus, for example,
SELECT * FROM SomeObj WHERE (param_a < '/some/kvp:10.0')
will search for the object where param_a is a KVP frame, and this KVP frame contains a path '/some/kvp' and the value stored at that path is floating-point and that float value is less than 10.0.

Parameters:
sql_query Examples:
"select * from pilot_address"

"select * from pilot_expenses where type_of_expense = 'Mileage';"

"SELECT * from pilot_datebook where start_time > '2004-04-06T00:00Z' and end_time < '2005-04-05T23:59:59Z';"

"insert into pilot_todo (description, date_due, todo_priority) values ('put the cat out', '2005-11-24T21:30:00Z', 1)"

Parameters:
data The QofMain context.

Definition at line 540 of file qof-main.c.

References QofMain_s::sql_str.

00541 {
00542         data->sql_str = g_strdup (sql_query);
00543 }

void qof_mod_sql_file ( const gchar *  sql_file,
QofMainContext data 
)

Specify one or more SQL queries contained in a file.

The rules for single SQL commands also apply with regard to the lack of explicit support for joins and the pending support for selecting only certain parameters from a certain object.

See qof_mod_sql for information on the queries supported.

Definition at line 546 of file qof-main.c.

References ERR_INDENT, qof_main_wrap_line(), QOF_SQL_SUPPORTED, QofMain_s::sql_file, and QofMain_s::sql_list.

00547 {
00548         FILE *filehandle;
00549 #ifndef HAVE_GETLINE
00550         gchar lineptr[1024];
00551 #else
00552         gchar *lineptr;
00553 #endif
00554         gchar *buf;
00555         size_t n;
00556         QofQuery *q;
00557         regex_t *r;
00558         gint reg_exp_check;
00559         const gchar *fmt;
00560         static gchar *pattern = QOF_SQL_SUPPORTED;
00561 
00562         ENTER (" ");
00563         data->sql_file = g_strdup (sql_file);
00564         n = 0;
00565         q = NULL;
00566         data->sql_list = NULL;
00567         filehandle = fopen (sql_file, "r");
00568         if (!filehandle)
00569         {
00570                 fmt = _("%s: There was an error reading the file '%s'.\n");
00571                 qof_main_wrap_line (stderr, ERR_INDENT, fmt, PACKAGE, sql_file);
00572                 return;
00573         }
00574         r = g_new (regex_t, 1);
00575 #ifndef HAVE_GETLINE
00576         while (NULL != (fgets (lineptr, sizeof (lineptr), filehandle)))
00577 #else
00578         lineptr = NULL;
00579         while (0 < getline (&lineptr, &n, filehandle))
00580 #endif
00581         {
00582                 reg_exp_check =
00583                         regcomp (r, pattern, REG_ICASE | REG_NOSUB | REG_EXTENDED);
00584                 g_return_if_fail (reg_exp_check == 0);
00585                 if (0 != regexec (r, lineptr, 0, NULL, 0))
00586                         continue;
00587                 buf = g_strdup (g_strchomp (lineptr));
00588                 data->sql_list = g_list_prepend (data->sql_list, buf);
00589         }
00590         regfree (r);
00591         g_free (r);
00592         fclose (filehandle);
00593         LEAVE (" sql_list=%d", g_list_length (data->sql_list));
00594 }

void qof_mod_time ( const gchar *  date_time,
QofMainContext data 
)

Shorthand to only query objects that contain the specified date.

Used to modify the QOF query to only query objects that contain at least one parameter containing a QOF_TYPE_TIME that matches the range specified. Dates need to be specified as YY-MM-DD, i.e. QOF_DATE_FORMAT_ISO.

You can specify a UTC timestring, just as normally output by QSF, but the time will not be matched when using the shorthand option, only the year, month and day.

For more precise time matches or to set a defined period that doesn't follow whole calendar months, (e.g. the UK financial year) use a SQL statement:

"SELECT * from pilot_datebook where start_time > '2004-04-06T00:00Z'
and end_time < '2005-04-05T23:59:59Z';"

Partial matches are allowed, so YY-MM matches any object where a date is within the specified month and year, YY matches any object where a date is within the specified year.

The query range starts at midnight on the first day of the range and ends at 1 second to midnight on the last day of the range.

Definition at line 485 of file qof-main.c.

References QofMain_s::max_qt, QofMain_s::min_qt, and qof_mod_get_local_offset().

00486 {
00487         QofDate *qd;
00488         gboolean all_year, all_month;
00489         gint adding_days;
00490         gchar *info;
00491 
00492         /* incoming date is assumed to be localtime */
00493         ENTER (" date_time=%s", date_time);
00494         all_month = all_year = FALSE;
00495         g_return_if_fail (date_time);
00496         qd = qof_date_parse (date_time, QOF_DATE_FORMAT_ISO);
00497         if (!qd)
00498                 qd = qof_date_parse (date_time, QOF_DATE_FORMAT_UTC);
00499         info = qof_date_print (qd, QOF_DATE_FORMAT_ISO8601);
00500         PINFO (" parsed start_time=%s", info);
00501         g_free (info);
00502         /* set first second of day, UTC */
00503         qof_date_set_day_start (qd);
00504         data->min_qt = qof_date_to_qtime (qd);
00505         /* adjust for incoming localtime */
00506         qof_time_add_secs (data->min_qt, 
00507                 qof_mod_get_local_offset());
00508         /* year specified but no month or day, select the entire year */
00509         if (strlen (date_time) == 4)
00510         {
00511                 PINFO (" match entire year %s", date_time);
00512                 /* go to end of this year, not first day of next. */
00513                 adding_days = qof_date_isleap(qd->qd_year) ? 365 : 364;
00514                 qof_date_adddays (qd, adding_days);
00515         }
00516         /* month specified, but no day, select entire month */
00517         if (strlen (date_time) == 7)
00518         {
00519                 PINFO (" match entire month %s", date_time);
00520                 adding_days = qof_date_get_mday (qd->qd_mon, qd->qd_year);
00521                 qof_date_adddays (qd, adding_days - 1);
00522         }
00523         /* set last second of day */
00524         qof_date_set_day_end (qd);
00525         data->max_qt = qof_date_to_qtime (qd);
00526         /* adjust for incoming localtime */
00527         qof_time_add_secs (data->max_qt, 
00528                 qof_mod_get_local_offset());
00529         LEAVE (" ");
00530 }

void qof_mod_write ( const gchar *  write_file,
QofMainContext data 
)

Write the results of any query to the file.

filename of the file to be written out.

Definition at line 597 of file qof-main.c.

References QofMain_s::write_file.

00598 {
00599         data->write_file = g_strdup (write_file);
00600 }


Generated on Wed Aug 26 20:31:42 2009 for gpe-expenses by  doxygen 1.5.9