1 /*
2 * Copyright (C) 2008 Bas Driessen <bas.driessen@xobas.com>
3 * Copyright (C) 2008 - 2011 Murray Cumming <murrayc@murrayc.com>
4 * Copyright (C) 2008 - 2012 Vivien Malerba <malerba@gnome-db.org>
5 * Copyright (C) 2010 David King <davidk@openismus.com>
6 * Copyright (C) 2010 Jonh Wendell <jwendell@gnome.org>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
21 * Boston, MA 02110-1301, USA.
22 */
23
24 #undef GDA_DISABLE_DEPRECATED
25 #include <string.h>
26 #include <glib/gi18n-lib.h>
27 #include <libgda/gda-statement.h>
28 #include <libgda/gda-debug-macros.h>
29 #include <libgda/sql-parser/gda-statement-struct-util.h>
30 #include <libgda/sql-parser/gda-statement-struct-parts.h>
31 #include <libgda/sql-parser/gda-statement-struct-unknown.h>
32 #include <libgda/sql-parser/gda-statement-struct-insert.h>
33 #include <libgda/sql-parser/gda-statement-struct-delete.h>
34 #include <libgda/sql-parser/gda-statement-struct-update.h>
35 #include <libgda/sql-parser/gda-statement-struct-compound.h>
36 #include <libgda/sql-parser/gda-statement-struct-select.h>
37 #include <libgda/gda-marshal.h>
38 #include <libgda/gda-data-handler.h>
39 #include <libgda/gda-server-provider.h>
40 #include <libgda/gda-statement-extra.h>
41 #include <libgda/gda-holder.h>
42 #include <libgda/gda-set.h>
43 #include <libgda/gda-meta-store.h>
44 #include <libgda/gda-connection.h>
45 #include <libgda/gda-util.h>
46 #include <libgda/libgda.h>
47
48 /*
49 * Main static functions
50 */
51 static void gda_statement_class_init (GdaStatementClass *klass);
52 static void gda_statement_init (GdaStatement *stmt);
53 static void gda_statement_dispose (GObject *object);
54 static void gda_statement_finalize (GObject *object);
55
56 static void gda_statement_set_property (GObject *object,
57 guint param_id,
58 const GValue *value,
59 GParamSpec *pspec);
60 static void gda_statement_get_property (GObject *object,
61 guint param_id,
62 GValue *value,
63 GParamSpec *pspec);
64 /* get a pointer to the parents to be able to call their destructor */
65 static GObjectClass *parent_class = NULL;
66
67 struct _GdaStatementPrivate {
68 GdaSqlStatement *internal_struct;
69 GType *requested_types;
70 };
71
72 /* signals */
73 enum
74 {
75 RESET,
76 CHECKED,
77 LAST_SIGNAL
78 };
79
80 static gint gda_statement_signals[LAST_SIGNAL] = { 0, 0 };
81
82 /* properties */
83 enum
84 {
85 PROP_0,
86 PROP_STRUCTURE
87 };
88
89 /* module error */
gda_statement_error_quark(void)90 GQuark gda_statement_error_quark (void)
91 {
92 static GQuark quark;
93 if (!quark)
94 quark = g_quark_from_static_string ("gda_statement_error");
95 return quark;
96 }
97
98
99 GType
gda_statement_get_type(void)100 gda_statement_get_type (void)
101 {
102 static GType type = 0;
103
104 if (G_UNLIKELY (type == 0)) {
105 static GMutex registering;
106 static const GTypeInfo info = {
107 sizeof (GdaStatementClass),
108 (GBaseInitFunc) NULL,
109 (GBaseFinalizeFunc) NULL,
110 (GClassInitFunc) gda_statement_class_init,
111 NULL,
112 NULL,
113 sizeof (GdaStatement),
114 0,
115 (GInstanceInitFunc) gda_statement_init,
116 0
117 };
118
119 g_mutex_lock (®istering);
120 if (type == 0)
121 type = g_type_register_static (G_TYPE_OBJECT, "GdaStatement", &info, 0);
122 g_mutex_unlock (®istering);
123 }
124 return type;
125 }
126
127 static void
gda_statement_class_init(GdaStatementClass * klass)128 gda_statement_class_init (GdaStatementClass * klass)
129 {
130 GObjectClass *object_class = G_OBJECT_CLASS (klass);
131 parent_class = g_type_class_peek_parent (klass);
132
133 /**
134 * GdaStatement::reset:
135 *
136 * Gets emitted whenever the statement has changed
137 */
138 gda_statement_signals[RESET] =
139 g_signal_new ("reset",
140 G_TYPE_FROM_CLASS (object_class),
141 G_SIGNAL_RUN_FIRST,
142 G_STRUCT_OFFSET (GdaStatementClass, reset),
143 NULL, NULL,
144 g_cclosure_marshal_VOID__VOID, G_TYPE_NONE,
145 0);
146 /**
147 * GdaStatement::checked:
148 *
149 * Gets emitted whenever the structure and contents
150 * of the statement have been verified (emitted after gda_statement_check_validity()).
151 */
152 gda_statement_signals[CHECKED] =
153 g_signal_new ("checked",
154 G_TYPE_FROM_CLASS (object_class),
155 G_SIGNAL_RUN_FIRST,
156 G_STRUCT_OFFSET (GdaStatementClass, checked),
157 NULL, NULL,
158 _gda_marshal_VOID__OBJECT_BOOLEAN, G_TYPE_NONE,
159 2, GDA_TYPE_CONNECTION, G_TYPE_BOOLEAN);
160
161 klass->reset = NULL;
162 klass->checked = NULL;
163
164 object_class->dispose = gda_statement_dispose;
165 object_class->finalize = gda_statement_finalize;
166
167 /* Properties */
168 object_class->set_property = gda_statement_set_property;
169 object_class->get_property = gda_statement_get_property;
170 g_object_class_install_property (object_class, PROP_STRUCTURE,
171 g_param_spec_pointer ("structure", NULL, NULL,
172 G_PARAM_WRITABLE | G_PARAM_READABLE));
173 }
174
175 static void
gda_statement_init(GdaStatement * stmt)176 gda_statement_init (GdaStatement * stmt)
177 {
178 stmt->priv = g_new0 (GdaStatementPrivate, 1);
179 stmt->priv->internal_struct = NULL;
180 stmt->priv->requested_types = NULL;
181 }
182
183 /**
184 * gda_statement_new:
185 *
186 * Creates a new #GdaStatement object
187 *
188 * Returns: the new object
189 */
190 GdaStatement*
gda_statement_new(void)191 gda_statement_new (void)
192 {
193 GObject *obj;
194
195 obj = g_object_new (GDA_TYPE_STATEMENT, NULL);
196 return GDA_STATEMENT (obj);
197 }
198
199 GdaSqlStatement *
_gda_statement_get_internal_struct(GdaStatement * stmt)200 _gda_statement_get_internal_struct (GdaStatement *stmt)
201 {
202 return stmt->priv->internal_struct;
203 }
204
205 /**
206 * gda_statement_copy:
207 * @orig: a #GdaStatement to make a copy of
208 *
209 * Copy constructor
210 *
211 * Returns: (transfer full): a the new copy of @orig
212 */
213 GdaStatement *
gda_statement_copy(GdaStatement * orig)214 gda_statement_copy (GdaStatement *orig)
215 {
216 GObject *obj;
217
218 g_return_val_if_fail (GDA_IS_STATEMENT (orig), NULL);
219
220 obj = g_object_new (GDA_TYPE_STATEMENT, "structure", orig->priv->internal_struct, NULL);
221 return GDA_STATEMENT (obj);
222 }
223
224 static void
gda_statement_dispose(GObject * object)225 gda_statement_dispose (GObject *object)
226 {
227 GdaStatement *stmt;
228
229 g_return_if_fail (object != NULL);
230 g_return_if_fail (GDA_IS_STATEMENT (object));
231
232 stmt = GDA_STATEMENT (object);
233 if (stmt->priv) {
234 if (stmt->priv->requested_types) {
235 g_free (stmt->priv->requested_types);
236 stmt->priv->requested_types = NULL;
237 }
238 if (stmt->priv->internal_struct) {
239 gda_sql_statement_free (stmt->priv->internal_struct);
240 stmt->priv->internal_struct = NULL;
241 }
242 }
243
244 /* parent class */
245 parent_class->dispose (object);
246 }
247
248 static void
gda_statement_finalize(GObject * object)249 gda_statement_finalize (GObject *object)
250 {
251 GdaStatement *stmt;
252
253 g_return_if_fail (object != NULL);
254 g_return_if_fail (GDA_IS_STATEMENT (object));
255
256 stmt = GDA_STATEMENT (object);
257 if (stmt->priv) {
258 g_free (stmt->priv);
259 stmt->priv = NULL;
260 }
261
262 /* parent class */
263 parent_class->finalize (object);
264 }
265
266
267 static void
gda_statement_set_property(GObject * object,guint param_id,const GValue * value,GParamSpec * pspec)268 gda_statement_set_property (GObject *object,
269 guint param_id,
270 const GValue *value,
271 GParamSpec *pspec)
272 {
273 GdaStatement *stmt;
274
275 stmt = GDA_STATEMENT (object);
276 if (stmt->priv) {
277 switch (param_id) {
278 case PROP_STRUCTURE:
279 if (stmt->priv->internal_struct) {
280 gda_sql_statement_free (stmt->priv->internal_struct);
281 stmt->priv->internal_struct = NULL;
282 }
283 if (stmt->priv->requested_types) {
284 g_free (stmt->priv->requested_types);
285 stmt->priv->requested_types = NULL;
286 }
287 stmt->priv->internal_struct = gda_sql_statement_copy (g_value_get_pointer (value));
288 g_signal_emit (stmt, gda_statement_signals [RESET], 0);
289 break;
290 default:
291 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
292 break;
293 }
294 }
295 }
296
297 static void
gda_statement_get_property(GObject * object,guint param_id,GValue * value,GParamSpec * pspec)298 gda_statement_get_property (GObject *object,
299 guint param_id,
300 GValue *value,
301 GParamSpec *pspec)
302 {
303 GdaStatement *stmt;
304 stmt = GDA_STATEMENT (object);
305
306 if (stmt->priv) {
307 switch (param_id) {
308 case PROP_STRUCTURE:
309 g_value_set_pointer (value, gda_sql_statement_copy (stmt->priv->internal_struct));
310 break;
311 default:
312 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
313 break;
314 }
315 }
316 }
317
318 /**
319 * gda_statement_get_statement_type:
320 * @stmt: a #GdaStatement object
321 *
322 * Get the type of statement held by @stmt. It returns GDA_SQL_STATEMENT_NONE if
323 * @stmt does not hold any statement
324 *
325 * Returns: (transfer none): the statement type
326 */
327 GdaSqlStatementType
gda_statement_get_statement_type(GdaStatement * stmt)328 gda_statement_get_statement_type (GdaStatement *stmt)
329 {
330 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), GDA_SQL_STATEMENT_NONE);
331 g_return_val_if_fail (stmt->priv, GDA_SQL_STATEMENT_NONE);
332
333 if (stmt->priv->internal_struct)
334 return stmt->priv->internal_struct->stmt_type;
335 else
336 return GDA_SQL_STATEMENT_NONE;
337 }
338
339 /**
340 * gda_statement_is_useless:
341 * @stmt: a #GdaStatement object
342 *
343 * Tells if @stmt is composed only of spaces (that is it has no real SQL code), and is completely
344 * useless as such.
345 *
346 * Returns: TRUE if executing @stmt does nothing
347 */
348 gboolean
gda_statement_is_useless(GdaStatement * stmt)349 gda_statement_is_useless (GdaStatement *stmt)
350 {
351 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), FALSE);
352 g_return_val_if_fail (stmt->priv, FALSE);
353
354 if (stmt->priv->internal_struct &&
355 stmt->priv->internal_struct->stmt_type == GDA_SQL_STATEMENT_UNKNOWN) {
356 GSList *list;
357 GdaSqlStatementUnknown *unknown;
358 unknown = (GdaSqlStatementUnknown*) stmt->priv->internal_struct->contents;
359 for (list = unknown->expressions; list; list = list->next) {
360 GdaSqlExpr *expr = (GdaSqlExpr *) list->data;
361 if (expr->param_spec)
362 return FALSE;
363 if (expr->value) {
364 if (G_VALUE_TYPE (expr->value) == G_TYPE_STRING) {
365 const gchar *str;
366 for (str = g_value_get_string (expr->value);
367 (*str == ' ') || (*str == '\t') || (*str == '\n') ||
368 (*str == '\f') || (*str == '\r'); str++);
369 if (*str)
370 return FALSE;
371 }
372 else {
373 TO_IMPLEMENT;
374 return FALSE;
375 }
376 }
377 }
378 return TRUE;
379 }
380 return FALSE;
381 }
382
383 /**
384 * gda_statement_check_structure:
385 * @stmt: a #GdaStatement object
386 * @error: a place to store errors, or %NULL
387 *
388 * Checks that @stmt's structure is correct.
389 *
390 * Returns: TRUE if @stmt's structure is correct
391 */
392 gboolean
gda_statement_check_structure(GdaStatement * stmt,GError ** error)393 gda_statement_check_structure (GdaStatement *stmt, GError **error)
394 {
395 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), FALSE);
396 g_return_val_if_fail (stmt->priv, FALSE);
397
398 return gda_sql_statement_check_structure (stmt->priv->internal_struct, error);
399 }
400
401 /**
402 * gda_statement_check_validity:
403 * @stmt: a #GdaStatement object
404 * @cnc: (allow-none): a #GdaConnection object, or %NULL
405 * @error: a place to store errors, or %NULL
406 *
407 * If @cnc is not %NULL then checks that every object (table, field, function) used in @stmt
408 * actually exists in @cnc's database
409 *
410 * If @cnc is %NULL, then cleans anything related to @cnc in @stmt.
411 *
412 * See gda_sql_statement_check_validity() for more information.
413 *
414 * Returns: TRUE if every object actually exists in @cnc's database
415 */
416 gboolean
gda_statement_check_validity(GdaStatement * stmt,GdaConnection * cnc,GError ** error)417 gda_statement_check_validity (GdaStatement *stmt, GdaConnection *cnc, GError **error)
418 {
419 gboolean retval;
420 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), FALSE);
421 g_return_val_if_fail (stmt->priv, FALSE);
422 g_return_val_if_fail (!cnc || GDA_IS_CONNECTION (cnc), FALSE);
423
424 retval = gda_sql_statement_check_validity (stmt->priv->internal_struct, cnc, error);
425 g_signal_emit (stmt, gda_statement_signals [CHECKED], 0, cnc, retval);
426
427 return retval;
428 }
429
430 /**
431 * gda_statement_normalize:
432 * @stmt: a #GdaStatement object
433 * @cnc: a #GdaConnection object
434 * @error: a place to store errors, or %NULL
435 *
436 * "Normalizes" some parts of @stmt, see gda_sql_statement_normalize() for more
437 * information.
438 *
439 * Returns: TRUE if no error occurred
440 */
441 gboolean
gda_statement_normalize(GdaStatement * stmt,GdaConnection * cnc,GError ** error)442 gda_statement_normalize (GdaStatement *stmt, GdaConnection *cnc, GError **error)
443 {
444 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), FALSE);
445 g_return_val_if_fail (stmt->priv, FALSE);
446 g_return_val_if_fail (GDA_IS_CONNECTION (cnc), FALSE);
447
448 return gda_sql_statement_normalize (stmt->priv->internal_struct, cnc, error);
449 }
450
451 /**
452 * gda_statement_serialize:
453 * @stmt: a #GdaStatement object
454 *
455 * Creates a string representing the contents of @stmt.
456 *
457 * Returns: a string containing the serialized version of @stmt
458 */
459 gchar *
gda_statement_serialize(GdaStatement * stmt)460 gda_statement_serialize (GdaStatement *stmt)
461 {
462 gchar *str;
463 GString *string;
464 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), NULL);
465 g_return_val_if_fail (stmt->priv, NULL);
466
467 string = g_string_new ("{");
468 g_string_append (string, "\"statement\":");
469 str = gda_sql_statement_serialize (stmt->priv->internal_struct);
470 if (str) {
471 g_string_append (string, str);
472 g_free (str);
473 }
474 else
475 g_string_append (string, "null");
476 g_string_append_c (string, '}');
477
478 str = string->str;
479 g_string_free (string, FALSE);
480 return str;
481 }
482
483 static gboolean
get_params_foreach_func(GdaSqlAnyPart * node,GdaSet ** params,GError ** error)484 get_params_foreach_func (GdaSqlAnyPart *node, GdaSet **params, GError **error)
485 {
486 GdaSqlParamSpec *pspec;
487 if (!node) return TRUE;
488
489 if ((node->type == GDA_SQL_ANY_EXPR) &&
490 (pspec = ((GdaSqlExpr*) node)->param_spec)) {
491 GdaHolder *h;
492
493 if (pspec->g_type == GDA_TYPE_NULL) {
494 g_set_error (error, GDA_STATEMENT_ERROR, GDA_STATEMENT_PARAM_TYPE_ERROR,
495 _("Could not determine GType for parameter '%s'"),
496 pspec->name ? pspec->name : _("Unnamed"));
497 return FALSE;
498 }
499 if (!*params)
500 *params = gda_set_new (NULL);
501 h = gda_holder_new (pspec->g_type);
502 g_object_set (G_OBJECT (h), "id", pspec->name, "name", pspec->name,
503 "description", pspec->descr, NULL);
504 gda_holder_set_not_null (h, ! pspec->nullok);
505 if (((GdaSqlExpr*) node)->value) {
506 /* Expr's value is "SQL encoded" => we need to convert it to a real value */
507 GValue *evalue;
508 evalue = ((GdaSqlExpr*) node)->value;
509 if (G_VALUE_TYPE (evalue) == G_TYPE_STRING) {
510 GdaDataHandler *dh;
511 GValue *value;
512 dh = gda_data_handler_get_default (pspec->g_type);
513 if (!dh) {
514 g_set_error (error, GDA_STATEMENT_ERROR, GDA_STATEMENT_PARAM_TYPE_ERROR,
515 _("Can't handle default value of type '%s'"),
516 gda_g_type_to_string (pspec->g_type));
517 g_object_unref (h);
518 return FALSE;
519 }
520 value = gda_data_handler_get_value_from_sql (dh,
521 g_value_get_string (evalue),
522 pspec->g_type);
523 if (!value)
524 value = gda_value_new_default (g_value_get_string (evalue));
525 gda_holder_set_default_value (h, value);
526 gda_value_free (value);
527 }
528 else
529 gda_holder_set_default_value (h, ((GdaSqlExpr*) node)->value);
530 gda_holder_set_value_to_default (h);
531 }
532 gda_set_add_holder (*params, h);
533 g_object_unref (h);
534 }
535 return TRUE;
536 }
537
538 /**
539 * gda_statement_get_parameters:
540 * @stmt: a #GdaStatement object
541 * @out_params: (out) (allow-none) (transfer full): a place to store a new #GdaSet object, or %NULL
542 * @error: a place to store errors, or %NULL
543 *
544 * Get a new #GdaSet object which groups all the execution parameters
545 * which @stmt needs. This new object is returned though @out_params.
546 *
547 * Note that if @stmt does not need any parameter, then @out_params is set to %NULL.
548 *
549 * Returns: TRUE if no error occurred.
550 */
551 gboolean
gda_statement_get_parameters(GdaStatement * stmt,GdaSet ** out_params,GError ** error)552 gda_statement_get_parameters (GdaStatement *stmt, GdaSet **out_params, GError **error)
553 {
554 GdaSet *set = NULL;
555 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), FALSE);
556 g_return_val_if_fail (stmt->priv, FALSE);
557
558 if (out_params)
559 *out_params = NULL;
560
561 if (!gda_sql_any_part_foreach (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents),
562 (GdaSqlForeachFunc) get_params_foreach_func, &set, error)) {
563 if (set) {
564 g_object_unref (set);
565 set = NULL;
566 }
567 return FALSE;
568 }
569
570 if (out_params)
571 *out_params = set;
572 else
573 g_object_unref (set);
574 return TRUE;
575 }
576
577 /*
578 * _gda_statement_get_requested_types:
579 * @stmt: a #GdaStatement
580 *
581 * Returns: a new #GType, suitable to use with gda_connection_statement_execute_select_full(), or %NULL
582 */
583 const GType *
_gda_statement_get_requested_types(GdaStatement * stmt)584 _gda_statement_get_requested_types (GdaStatement *stmt)
585 {
586 if (! stmt->priv || ! stmt->priv->internal_struct)
587 return NULL;
588 if (stmt->priv->requested_types)
589 return stmt->priv->requested_types;
590 if (stmt->priv->internal_struct->stmt_type != GDA_SQL_STATEMENT_SELECT)
591 return NULL;
592
593 GdaSqlStatementSelect *selst;
594 GSList *list;
595 GArray *array = NULL;
596 rewind:
597 selst = (GdaSqlStatementSelect*) stmt->priv->internal_struct->contents;
598 for (list = selst->expr_list; list; list = list->next) {
599 GdaSqlExpr *expr;
600 GType type = G_TYPE_INVALID;
601 expr = ((GdaSqlSelectField*) list->data)->expr;
602 if (expr->cast_as && *expr->cast_as)
603 type = gda_g_type_from_string (expr->cast_as);
604 if (array) {
605 if (type == G_TYPE_INVALID)
606 type = 0;
607 g_array_append_val (array, type);
608 }
609 else if (type != G_TYPE_INVALID) {
610 array = g_array_new (TRUE, FALSE, sizeof (GType));
611 goto rewind;
612 }
613 }
614 if (array) {
615 GType *retval;
616 guint len;
617 len = array->len;
618 retval = (GType*) g_array_free (array, FALSE);
619 retval [len] = G_TYPE_NONE;
620 stmt->priv->requested_types = retval;
621 return retval;
622 }
623 else
624 return NULL;
625 }
626
627
628 /*
629 * SQL rendering
630 */
631 static gchar *default_render_value (const GValue *value, GdaSqlRenderingContext *context, GError **error);
632 static gchar *default_render_param_spec (GdaSqlParamSpec *pspec, GdaSqlExpr *expr, GdaSqlRenderingContext *context,
633 gboolean *is_default, gboolean *is_null, GError **error);
634
635 static gchar *default_render_unknown (GdaSqlStatementUnknown *stmt, GdaSqlRenderingContext *context, GError **error);
636 static gchar *default_render_select (GdaSqlStatementSelect *stmt, GdaSqlRenderingContext *context, GError **error);
637 static gchar *default_render_insert (GdaSqlStatementInsert *stmt, GdaSqlRenderingContext *context, GError **error);
638 static gchar *default_render_delete (GdaSqlStatementDelete *stmt, GdaSqlRenderingContext *context, GError **error);
639 static gchar *default_render_update (GdaSqlStatementUpdate *stmt, GdaSqlRenderingContext *context, GError **error);
640 static gchar *default_render_compound (GdaSqlStatementCompound *stmt, GdaSqlRenderingContext *context, GError **error);
641
642 static gchar *default_render_expr (GdaSqlExpr *expr, GdaSqlRenderingContext *context,
643 gboolean *is_default, gboolean *is_null, GError **error);
644 static gchar *default_render_table (GdaSqlTable *table, GdaSqlRenderingContext *context, GError **error);
645 static gchar *default_render_field (GdaSqlField *field, GdaSqlRenderingContext *context, GError **error);
646 static gchar *default_render_function (GdaSqlFunction *func, GdaSqlRenderingContext *context, GError **error);
647 static gchar *default_render_operation (GdaSqlOperation *op, GdaSqlRenderingContext *context, GError **error);
648 static gchar *default_render_case (GdaSqlCase *case_s, GdaSqlRenderingContext *context, GError **error);
649 static gchar *default_render_select_field (GdaSqlSelectField *field, GdaSqlRenderingContext *context, GError **error);
650 static gchar *default_render_select_target (GdaSqlSelectTarget *target, GdaSqlRenderingContext *context, GError **error);
651 static gchar *default_render_select_join (GdaSqlSelectJoin *join, GdaSqlRenderingContext *context, GError **error);
652 static gchar *default_render_select_from (GdaSqlSelectFrom *from, GdaSqlRenderingContext *context, GError **error);
653 static gchar *default_render_select_order (GdaSqlSelectOrder *order, GdaSqlRenderingContext *context, GError **error);
654 static gchar *default_render_distinct (GdaSqlStatementSelect *select, GdaSqlRenderingContext *context, GError **error);
655
656 /**
657 * gda_statement_to_sql_real:
658 * @stmt: a #GdaStatement object
659 * @context: a #GdaSqlRenderingContext context
660 * @error: a place to store errors, or %NULL
661 *
662 * Renders @stmt to its SQL representation, using @context to specify how each part of @stmt must
663 * be rendered. This function is mainly used by database provider's implementations which require
664 * to specialize some aspects of SQL rendering to be adapted to the database,'s own SQL dialect
665 * (for example SQLite rewrites the 'FALSE' and 'TRUE' literals as '0' and 'NOT 0').
666 *
667 * Returns: a new string, or %NULL if an error occurred
668 */
669 gchar *
gda_statement_to_sql_real(GdaStatement * stmt,GdaSqlRenderingContext * context,GError ** error)670 gda_statement_to_sql_real (GdaStatement *stmt, GdaSqlRenderingContext *context, GError **error)
671 {
672 GdaSqlStatementContentsInfo *cinfo;
673 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), NULL);
674 g_return_val_if_fail (stmt->priv, NULL);
675
676 if (!context->render_value)
677 context->render_value = default_render_value;
678 if (!context->render_param_spec)
679 context->render_param_spec = default_render_param_spec;
680 if (!context->render_expr)
681 context->render_expr = default_render_expr;
682
683 if (!context->render_unknown)
684 context->render_unknown = (GdaSqlRenderingFunc) default_render_unknown;
685 if (!context->render_select)
686 context->render_select = (GdaSqlRenderingFunc) default_render_select;
687 if (!context->render_insert)
688 context->render_insert = (GdaSqlRenderingFunc) default_render_insert;
689 if (!context->render_delete)
690 context->render_delete = (GdaSqlRenderingFunc) default_render_delete;
691 if (!context->render_update)
692 context->render_update = (GdaSqlRenderingFunc) default_render_update;
693 if (!context->render_compound)
694 context->render_compound = (GdaSqlRenderingFunc) default_render_compound;
695
696 if (!context->render_table)
697 context->render_table = (GdaSqlRenderingFunc) default_render_table;
698 if (!context->render_field)
699 context->render_field = (GdaSqlRenderingFunc) default_render_field;
700 if (!context->render_function)
701 context->render_function = (GdaSqlRenderingFunc) default_render_function;
702 if (!context->render_operation)
703 context->render_operation = (GdaSqlRenderingFunc) default_render_operation;
704 if (!context->render_case)
705 context->render_case = (GdaSqlRenderingFunc) default_render_case;
706 if (!context->render_select_field)
707 context->render_select_field = (GdaSqlRenderingFunc) default_render_select_field;
708 if (!context->render_select_target)
709 context->render_select_target = (GdaSqlRenderingFunc) default_render_select_target;
710 if (!context->render_select_join)
711 context->render_select_join = (GdaSqlRenderingFunc) default_render_select_join;
712 if (!context->render_select_from)
713 context->render_select_from = (GdaSqlRenderingFunc) default_render_select_from;
714 if (!context->render_select_order)
715 context->render_select_order = (GdaSqlRenderingFunc) default_render_select_order;
716 if (!context->render_distinct)
717 context->render_distinct = (GdaSqlRenderingFunc) default_render_distinct;
718
719 cinfo = gda_sql_statement_get_contents_infos (stmt->priv->internal_struct->stmt_type);
720 if (cinfo->check_structure_func && !cinfo->check_structure_func (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents),
721 NULL, error))
722 return NULL;
723
724 switch (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents)->type) {
725 case GDA_SQL_ANY_STMT_UNKNOWN:
726 return context->render_unknown (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
727 case GDA_SQL_ANY_STMT_BEGIN:
728 if (context->render_begin)
729 return context->render_begin (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
730 break;
731 case GDA_SQL_ANY_STMT_ROLLBACK:
732 if (context->render_rollback)
733 return context->render_rollback (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
734 break;
735 case GDA_SQL_ANY_STMT_COMMIT:
736 if (context->render_commit)
737 return context->render_commit (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
738 break;
739 case GDA_SQL_ANY_STMT_SAVEPOINT:
740 if (context->render_savepoint)
741 return context->render_savepoint (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
742 break;
743 case GDA_SQL_ANY_STMT_ROLLBACK_SAVEPOINT:
744 if (context->render_rollback_savepoint)
745 return context->render_rollback_savepoint (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
746 break;
747 case GDA_SQL_ANY_STMT_DELETE_SAVEPOINT:
748 if (context->render_delete_savepoint)
749 return context->render_delete_savepoint (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
750 break;
751 case GDA_SQL_ANY_STMT_SELECT:
752 return context->render_select (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
753 case GDA_SQL_ANY_STMT_INSERT:
754 return context->render_insert (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
755 case GDA_SQL_ANY_STMT_DELETE:
756 return context->render_delete (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
757 case GDA_SQL_ANY_STMT_UPDATE:
758 return context->render_update (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
759 case GDA_SQL_ANY_STMT_COMPOUND:
760 return context->render_compound (GDA_SQL_ANY_PART (stmt->priv->internal_struct->contents), context, error);
761 default:
762 TO_IMPLEMENT;
763 return NULL;
764 break;
765 }
766
767 /* default action is to use stmt->priv->internal_struct->sql */
768 if (stmt->priv->internal_struct->sql)
769 return g_strdup (stmt->priv->internal_struct->sql);
770 else {
771 g_set_error (error, GDA_SQL_ERROR, GDA_SQL_STRUCTURE_CONTENTS_ERROR,
772 "%s", _("Missing SQL code"));
773 return NULL;
774 }
775 }
776
777 static gchar *
default_render_value(const GValue * value,GdaSqlRenderingContext * context,GError ** error)778 default_render_value (const GValue *value, GdaSqlRenderingContext *context, GError **error)
779 {
780 if (value && !gda_value_is_null (value)) {
781 GdaDataHandler *dh;
782 if (context->provider)
783 dh = gda_server_provider_get_data_handler_g_type (context->provider, context->cnc, G_VALUE_TYPE (value));
784 else
785 dh = gda_data_handler_get_default (G_VALUE_TYPE (value));
786
787 if (!dh) {
788 if (G_VALUE_TYPE (value) == GDA_TYPE_DEFAULT)
789 return g_strdup ("DEFAULT");
790 else {
791 g_set_error (error, GDA_SQL_ERROR, GDA_SQL_STRUCTURE_CONTENTS_ERROR,
792 _("No data handler for type '%s'"),
793 g_type_name (G_VALUE_TYPE (value)));
794 return NULL;
795 }
796 }
797 if (context->flags & GDA_STATEMENT_SQL_TIMEZONE_TO_GMT) {
798 if (G_VALUE_TYPE (value) == GDA_TYPE_TIME) {
799 GdaTime *nts;
800 nts = (GdaTime*) gda_value_get_time (value);
801 if (nts && (nts->timezone != GDA_TIMEZONE_INVALID)) {
802 nts = gda_time_copy (nts);
803 gda_time_change_timezone (nts, 0);
804 nts->timezone = GDA_TIMEZONE_INVALID;
805 GValue v = {0};
806 g_value_init (&v, GDA_TYPE_TIME);
807 gda_value_set_time (&v, nts);
808 gda_time_free (nts);
809 gchar *tmp;
810 tmp = gda_data_handler_get_sql_from_value (dh, &v);
811 g_value_reset (&v);
812 return tmp;
813 }
814 }
815 else if (G_VALUE_TYPE (value) == GDA_TYPE_TIMESTAMP) {
816 GdaTimestamp *nts;
817 nts = (GdaTimestamp*) gda_value_get_timestamp (value);
818 if (nts && (nts->timezone != GDA_TIMEZONE_INVALID)) {
819 nts = gda_timestamp_copy (nts);
820 gda_timestamp_change_timezone (nts, 0);
821 nts->timezone = GDA_TIMEZONE_INVALID;
822 GValue v = {0};
823 g_value_init (&v, GDA_TYPE_TIMESTAMP);
824 gda_value_set_timestamp (&v, nts);
825 gda_timestamp_free (nts);
826 gchar *tmp;
827 tmp = gda_data_handler_get_sql_from_value (dh, &v);
828 g_value_reset (&v);
829 return tmp;
830 }
831 }
832 }
833
834 return gda_data_handler_get_sql_from_value (dh, value);
835 }
836 else
837 return g_strdup ("NULL");
838 }
839
840 /**
841 * gda_statement_to_sql_extended:
842 * @stmt: a #GdaStatement object
843 * @cnc: (allow-none): a #GdaConnection object, or %NULL
844 * @params: (allow-none): parameters contained in a single #GdaSet object, or %NULL
845 * @flags: a set of flags to control the rendering
846 * @params_used: (element-type GdaHolder) (out) (transfer container) (allow-none):a place to store the list of actual #GdaHolder objects in @params used to do the rendering, or %NULL
847 * @error: a place to store errors, or %NULL
848 *
849 * Renders @stmt as an SQL statement, with some control on how it is rendered.
850 *
851 * If @cnc is not %NULL, then the rendered SQL will better be suited to be used by @cnc (in particular
852 * it may include some SQL tweaks and/or proprietary extensions specific to the database engine used by @cnc):
853 * in this case the result is similar to calling gda_connection_statement_to_sql().
854 *
855 * Returns: (transfer full): a new string if no error occurred
856 */
857 gchar *
gda_statement_to_sql_extended(GdaStatement * stmt,GdaConnection * cnc,GdaSet * params,GdaStatementSqlFlag flags,GSList ** params_used,GError ** error)858 gda_statement_to_sql_extended (GdaStatement *stmt, GdaConnection *cnc, GdaSet *params,
859 GdaStatementSqlFlag flags,
860 GSList **params_used, GError **error)
861 {
862 gchar *str;
863 GdaSqlRenderingContext context;
864
865 g_return_val_if_fail (GDA_IS_STATEMENT (stmt), NULL);
866 g_return_val_if_fail (stmt->priv, NULL);
867
868 memset (&context, 0, sizeof (context));
869 context.params = params;
870 context.flags = flags;
871 if (cnc) {
872 GdaServerProvider *prov;
873 prov = gda_connection_get_provider (cnc);
874 #define PROV_CLASS(provider) (GDA_SERVER_PROVIDER_CLASS (G_OBJECT_GET_CLASS (provider)))
875 if (prov && PROV_CLASS (prov)->statement_to_sql)
876 return (PROV_CLASS (prov)->statement_to_sql) (prov,
877 cnc, stmt, params, flags,
878 params_used, error);
879 context.cnc = cnc;
880 context.provider = gda_connection_get_provider (cnc);
881 }
882
883 str = gda_statement_to_sql_real (stmt, &context, error);
884
885 if (str) {
886 if (params_used)
887 *params_used = context.params_used;
888 else
889 g_slist_free (context.params_used);
890 }
891 else {
892 if (params_used)
893 *params_used = NULL;
894 g_slist_free (context.params_used);
895 }
896 return str;
897 }
898
899 static gchar *
default_render_unknown(GdaSqlStatementUnknown * stmt,GdaSqlRenderingContext * context,GError ** error)900 default_render_unknown (GdaSqlStatementUnknown *stmt, GdaSqlRenderingContext *context, GError **error)
901 {
902 GString *string;
903 gchar *str;
904 GSList *list;
905
906 g_return_val_if_fail (stmt, NULL);
907 g_return_val_if_fail (GDA_SQL_ANY_PART (stmt)->type == GDA_SQL_ANY_STMT_UNKNOWN, NULL);
908
909 string = g_string_new ("");
910 for (list = stmt->expressions; list; list = list->next) {
911 str = context->render_expr ((GdaSqlExpr*) list->data, context, NULL, NULL, error);
912 if (!str) goto err;
913 g_string_append (string, str);
914 g_free (str);
915 }
916
917 str = string->str;
918 g_string_free (string, FALSE);
919 return str;
920
921 err:
922 g_string_free (string, TRUE);
923 return NULL;
924 }
925
926 static gchar *
default_render_insert(GdaSqlStatementInsert * stmt,GdaSqlRenderingContext * context,GError ** error)927 default_render_insert (GdaSqlStatementInsert *stmt, GdaSqlRenderingContext *context, GError **error)
928 {
929 GString *string;
930 gchar *str;
931 GSList *list;
932 gboolean pretty = context->flags & GDA_STATEMENT_SQL_PRETTY;
933
934 g_return_val_if_fail (stmt, NULL);
935 g_return_val_if_fail (GDA_SQL_ANY_PART (stmt)->type == GDA_SQL_ANY_STMT_INSERT, NULL);
936
937 string = g_string_new ("INSERT ");
938
939 /* conflict algo */
940 if (stmt->on_conflict)
941 g_string_append_printf (string, "OR %s ", stmt->on_conflict);
942
943 /* INTO */
944 g_string_append (string, "INTO ");
945 str = context->render_table (GDA_SQL_ANY_PART (stmt->table), context, error);
946 if (!str) goto err;
947 g_string_append (string, str);
948 g_free (str);
949
950 /* fields list */
951 for (list = stmt->fields_list; list; list = list->next) {
952 if (list == stmt->fields_list)
953 g_string_append (string, " (");
954 else
955 g_string_append (string, ", ");
956 str = context->render_field (GDA_SQL_ANY_PART (list->data), context, error);
957 if (!str) goto err;
958 g_string_append (string, str);
959 g_free (str);
960 }
961 if (stmt->fields_list)
962 g_string_append_c (string, ')');
963
964 /* values */
965 if (stmt->select) {
966 if (pretty)
967 g_string_append_c (string, '\n');
968 else
969 g_string_append_c (string, ' ');
970 str = context->render_select (GDA_SQL_ANY_PART (stmt->select), context, error);
971 if (!str) goto err;
972 g_string_append (string, str);
973 g_free (str);
974 }
975 else {
976 for (list = stmt->values_list; list; list = list->next) {
977 GSList *rlist;
978 if (list == stmt->values_list) {
979 if (pretty)
980 g_string_append (string, "\nVALUES");
981 else
982 g_string_append (string, " VALUES");
983 }
984 else
985 g_string_append_c (string, ',');
986 for (rlist = (GSList*) list->data; rlist; rlist = rlist->next) {
987 if (rlist == (GSList*) list->data)
988 g_string_append (string, " (");
989 else
990 g_string_append (string, ", ");
991 str = context->render_expr ((GdaSqlExpr*) rlist->data, context, NULL, NULL, error);
992 if (!str) goto err;
993 if (pretty && (rlist != (GSList*) list->data))
994 g_string_append (string, "\n\t");
995 g_string_append (string, str);
996 g_free (str);
997 }
998 g_string_append_c (string, ')');
999 }
1000
1001 if (!stmt->fields_list && !stmt->values_list)
1002 g_string_append (string, " DEFAULT VALUES");
1003 }
1004
1005 str = string->str;
1006 g_string_free (string, FALSE);
1007 return str;
1008
1009 err:
1010 g_string_free (string, TRUE);
1011 return NULL;
1012 }
1013
1014 static gchar *
default_render_delete(GdaSqlStatementDelete * stmt,GdaSqlRenderingContext * context,GError ** error)1015 default_render_delete (GdaSqlStatementDelete *stmt, GdaSqlRenderingContext *context, GError **error)
1016 {
1017 GString *string;
1018 gchar *str;
1019
1020 g_return_val_if_fail (stmt, NULL);
1021 g_return_val_if_fail (GDA_SQL_ANY_PART (stmt)->type == GDA_SQL_ANY_STMT_DELETE, NULL);
1022
1023 string = g_string_new ("DELETE FROM ");
1024
1025 /* FROM */
1026 str = context->render_table (GDA_SQL_ANY_PART (stmt->table), context, error);
1027 if (!str) goto err;
1028 g_string_append (string, str);
1029 g_free (str);
1030
1031 /* cond */
1032 if (stmt->cond) {
1033 g_string_append (string, " WHERE ");
1034 str = context->render_expr (stmt->cond, context, NULL, NULL, error);
1035 if (!str) goto err;
1036 g_string_append (string, str);
1037 g_free (str);
1038 }
1039
1040 str = string->str;
1041 g_string_free (string, FALSE);
1042 return str;
1043
1044 err:
1045 g_string_free (string, TRUE);
1046 return NULL;
1047 }
1048
1049 static gchar *
default_render_update(GdaSqlStatementUpdate * stmt,GdaSqlRenderingContext * context,GError ** error)1050 default_render_update (GdaSqlStatementUpdate *stmt, GdaSqlRenderingContext *context, GError **error)
1051 {
1052 GString *string;
1053 gchar *str;
1054 GSList *flist, *elist;
1055 gboolean pretty = context->flags & GDA_STATEMENT_SQL_PRETTY;
1056
1057 g_return_val_if_fail (stmt, NULL);
1058 g_return_val_if_fail (GDA_SQL_ANY_PART (stmt)->type == GDA_SQL_ANY_STMT_UPDATE, NULL);
1059
1060 string = g_string_new ("UPDATE ");
1061 /* conflict algo */
1062 if (stmt->on_conflict)
1063 g_string_append_printf (string, "OR %s ", stmt->on_conflict);
1064
1065 /* table */
1066 str = context->render_table (GDA_SQL_ANY_PART (stmt->table), context, error);
1067 if (!str) goto err;
1068 g_string_append (string, str);
1069 g_free (str);
1070
1071 /* columns set */
1072 if (pretty)
1073 g_string_append (string, "\nSET ");
1074 else
1075 g_string_append (string, " SET ");
1076 for (flist = stmt->fields_list, elist = stmt->expr_list;
1077 flist && elist;
1078 flist = flist->next, elist = elist->next) {
1079 if (flist != stmt->fields_list) {
1080 g_string_append (string, ", ");
1081 if (pretty)
1082 g_string_append (string, "\n\t");
1083 }
1084 str = context->render_field (GDA_SQL_ANY_PART (flist->data), context, error);
1085 if (!str) goto err;
1086 g_string_append (string, str);
1087 g_free (str);
1088 g_string_append_c (string, '=');
1089 str = context->render_expr ((GdaSqlExpr *) elist->data, context, NULL, NULL, error);
1090 if (!str) goto err;
1091 g_string_append (string, str);
1092 g_free (str);
1093 }
1094
1095 /* cond */
1096 if (stmt->cond) {
1097 if (pretty)
1098 g_string_append (string, "\nWHERE ");
1099 else
1100 g_string_append (string, " WHERE ");
1101 str = context->render_expr (stmt->cond, context, NULL, NULL, error);
1102 if (!str) goto err;
1103 g_string_append (string, str);
1104 g_free (str);
1105 }
1106
1107 str = string->str;
1108 g_string_free (string, FALSE);
1109 return str;
1110
1111 err:
1112 g_string_free (string, TRUE);
1113 return NULL;
1114 }
1115
1116 static gchar *
default_render_compound(GdaSqlStatementCompound * stmt,GdaSqlRenderingContext * context,GError ** error)1117 default_render_compound (GdaSqlStatementCompound *stmt, GdaSqlRenderingContext *context, GError **error)
1118 {
1119 GString *string;
1120 gchar *str;
1121 GSList *list;
1122
1123 g_return_val_if_fail (stmt, NULL);
1124 g_return_val_if_fail (GDA_SQL_ANY_PART (stmt)->type == GDA_SQL_ANY_STMT_COMPOUND, NULL);
1125
1126 string = g_string_new ("");
1127
1128 for (list = stmt->stmt_list; list; list = list->next) {
1129 GdaSqlStatement *sqlstmt = (GdaSqlStatement*) list->data;
1130 if (list != stmt->stmt_list) {
1131 switch (stmt->compound_type) {
1132 case GDA_SQL_STATEMENT_COMPOUND_UNION:
1133 g_string_append (string, " UNION ");
1134 break;
1135 case GDA_SQL_STATEMENT_COMPOUND_UNION_ALL:
1136 g_string_append (string, " UNION ALL ");
1137 break;
1138 case GDA_SQL_STATEMENT_COMPOUND_INTERSECT:
1139 g_string_append (string, " INTERSECT ");
1140 break;
1141 case GDA_SQL_STATEMENT_COMPOUND_INTERSECT_ALL:
1142 g_string_append (string, " INTERSECT ALL ");
1143 break;
1144 case GDA_SQL_STATEMENT_COMPOUND_EXCEPT:
1145 g_string_append (string, " EXCEPT ");
1146 break;
1147 case GDA_SQL_STATEMENT_COMPOUND_EXCEPT_ALL:
1148 g_string_append (string, " EXCEPT ALL ");
1149 break;
1150 default:
1151 g_assert_not_reached ();
1152 }
1153 }
1154 switch (sqlstmt->stmt_type) {
1155 case GDA_SQL_ANY_STMT_SELECT:
1156 str = context->render_select (GDA_SQL_ANY_PART (sqlstmt->contents), context, error);
1157 if (!str) goto err;
1158 g_string_append_c (string, '(');
1159 g_string_append (string, str);
1160 g_string_append_c (string, ')');
1161 g_free (str);
1162 break;
1163 case GDA_SQL_ANY_STMT_COMPOUND:
1164 str = context->render_compound (GDA_SQL_ANY_PART (sqlstmt->contents), context, error);
1165 if (!str) goto err;
1166 g_string_append_c (string, '(');
1167 g_string_append (string, str);
1168 g_string_append_c (string, ')');
1169 g_free (str);
1170 break;
1171 default:
1172 g_assert_not_reached ();
1173 }
1174 }
1175
1176 str = string->str;
1177 g_string_free (string, FALSE);
1178 return str;
1179
1180 err:
1181 g_string_free (string, TRUE);
1182 return NULL;
1183 }
1184
1185 static gchar *
default_render_distinct(GdaSqlStatementSelect * stmt,GdaSqlRenderingContext * context,GError ** error)1186 default_render_distinct (GdaSqlStatementSelect *stmt, GdaSqlRenderingContext *context, GError **error)
1187 {
1188 gboolean pretty = context->flags & GDA_STATEMENT_SQL_PRETTY;
1189 g_return_val_if_fail (stmt, NULL);
1190 g_return_val_if_fail (GDA_SQL_ANY_PART (stmt)->type == GDA_SQL_ANY_STMT_SELECT, NULL);
1191
1192 if (stmt->distinct) {
1193 GString *string;
1194 string = g_string_new ("DISTINCT");
1195 if (stmt->distinct_expr) {
1196 gchar *str;
1197 str = context->render_expr (stmt->distinct_expr, context, NULL, NULL, error);
1198 if (!str) {
1199 g_string_free (string, TRUE);
1200 return NULL;
1201 }
1202 g_string_append (string, " ON (");
1203 g_string_append (string, str);
1204 g_string_append (string, ") ");
1205 g_free (str);
1206 }
1207 if (pretty)
1208 g_string_append_c (string, '\n');
1209 return g_string_free (string, FALSE);
1210 }
1211 else
1212 return NULL;
1213 }
1214
1215 static gchar *
default_render_select(GdaSqlStatementSelect * stmt,GdaSqlRenderingContext * context,GError ** error)1216 default_render_select (GdaSqlStatementSelect *stmt, GdaSqlRenderingContext *context, GError **error)
1217 {
1218 GString *string;
1219 gchar *str;
1220 GSList *list;
1221 gboolean pretty = context->flags & GDA_STATEMENT_SQL_PRETTY;
1222
1223 g_return_val_if_fail (stmt, NULL);
1224 g_return_val_if_fail (GDA_SQL_ANY_PART (stmt)->type == GDA_SQL_ANY_STMT_SELECT, NULL);
1225
1226 string = g_string_new ("SELECT ");
1227 /* distinct */
1228 if (stmt->distinct) {
1229 str = context->render_distinct (GDA_SQL_ANY_PART (stmt), context, error);
1230 if (!str) goto err;
1231 g_string_append (string, str);
1232 g_string_append_c (string, ' ');
1233 g_free (str);
1234 }
1235
1236 /* selected expressions */
1237 for (list = stmt->expr_list; list; list = list->next) {
1238 str = context->render_select_field (GDA_SQL_ANY_PART (list->data), context, error);
1239 if (!str) goto err;
1240 if (list != stmt->expr_list)
1241 g_string_append (string, ", ");
1242 if (pretty)
1243 g_string_append (string, "\n\t");
1244 g_string_append (string, str);
1245 g_free (str);
1246 }
1247
1248 /* FROM */
1249 if (stmt->from) {
1250 str = context->render_select_from (GDA_SQL_ANY_PART (stmt->from), context, error);
1251 if (!str) goto err;
1252 if (pretty)
1253 g_string_append_c (string, '\n');
1254 else
1255 g_string_append_c (string, ' ');
1256 g_string_append (string, str);
1257 g_free (str);
1258 }
1259
1260 /* WHERE */
1261 if (stmt->where_cond) {
1262 if (pretty)
1263 g_string_append (string, "\nWHERE ");
1264 else
1265 g_string_append (string, " WHERE ");
1266 str = context->render_expr (stmt->where_cond, context, NULL, NULL, error);
1267 if (!str) goto err;
1268 g_string_append (string, str);
1269 g_free (str);
1270 }
1271
1272 /* GROUP BY */
1273 for (list = stmt->group_by; list; list = list->next) {
1274 str = context->render_expr (list->data, context, NULL, NULL, error);
1275 if (!str) goto err;
1276 if (list != stmt->group_by)
1277 g_string_append (string, ", ");
1278 else {
1279 if (pretty)
1280 g_string_append (string, "\nGROUP BY ");
1281 else
1282 g_string_append (string, " GROUP BY ");
1283 }
1284 g_string_append (string, str);
1285 g_free (str);
1286 }
1287
1288 /* HAVING */
1289 if (stmt->having_cond) {
1290 if (pretty)
1291 g_string_append (string, "\nHAVING ");
1292 else
1293 g_string_append (string, " HAVING ");
1294 str = context->render_expr (stmt->having_cond, context, NULL, NULL, error);
1295 if (!str) goto err;
1296 g_string_append (string, str);
1297 g_free (str);
1298 }
1299
1300 /* ORDER BY */
1301 for (list = stmt->order_by; list; list = list->next) {
1302 str = context->render_select_order (GDA_SQL_ANY_PART (list->data), context, error);
1303 if (!str) goto err;
1304 if (list != stmt->order_by)
1305 g_string_append (string, ", ");
1306 else {
1307 if (pretty)
1308 g_string_append (string, "\nORDER BY ");
1309 else
1310 g_string_append (string, " ORDER BY ");
1311 }
1312 g_string_append (string, str);
1313 g_free (str);
1314 }
1315
1316 /* LIMIT */
1317 if (stmt->limit_count) {
1318 g_string_append (string, " LIMIT ");
1319 str = context->render_expr (stmt->limit_count, context, NULL, NULL, error);
1320 if (!str) goto err;
1321 g_string_append (string, str);
1322 g_free (str);
1323 if (stmt->limit_offset) {
1324 g_string_append (string, " OFFSET ");
1325 str = context->render_expr (stmt->limit_offset, context, NULL, NULL, error);
1326 if (!str) goto err;
1327 g_string_append (string, str);
1328 g_free (str);
1329 }
1330 }
1331
1332 str = string->str;
1333 g_string_free (string, FALSE);
1334 return str;
1335
1336 err:
1337 g_string_free (string, TRUE);
1338 return NULL;
1339 }
1340
1341 /*
1342 * Randers @pspec, and the default value stored in @expr->value if it exists
1343 */
1344 static gchar *
default_render_param_spec(GdaSqlParamSpec * pspec,GdaSqlExpr * expr,GdaSqlRenderingContext * context,gboolean * is_default,gboolean * is_null,GError ** error)1345 default_render_param_spec (GdaSqlParamSpec *pspec, GdaSqlExpr *expr, GdaSqlRenderingContext *context,
1346 gboolean *is_default, gboolean *is_null, GError **error)
1347 {
1348 GString *string;
1349 gchar *str;
1350 GdaHolder *h = NULL;
1351 gboolean render_pspec; /* if TRUE, then don't render parameter as its value but as a param specification */
1352
1353 g_return_val_if_fail (pspec, NULL);
1354
1355 render_pspec = FALSE;
1356 if (context->flags & (GDA_STATEMENT_SQL_PARAMS_LONG |
1357 GDA_STATEMENT_SQL_PARAMS_SHORT |
1358 GDA_STATEMENT_SQL_PARAMS_AS_COLON |
1359 GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR |
1360 GDA_STATEMENT_SQL_PARAMS_AS_QMARK |
1361 GDA_STATEMENT_SQL_PARAMS_AS_UQMARK))
1362 render_pspec = TRUE;
1363
1364 if (is_default)
1365 *is_default = FALSE;
1366 if (is_null)
1367 *is_null = FALSE;
1368
1369 string = g_string_new ("");
1370
1371 /* try to use a GdaHolder in context->params */
1372 if (context->params) {
1373 h = gda_set_get_holder (context->params, pspec->name);
1374 if (h && (gda_holder_get_g_type (h) != pspec->g_type)) {
1375 g_set_error (error, GDA_STATEMENT_ERROR, GDA_STATEMENT_PARAM_ERROR,
1376 _("Wrong parameter type for '%s': expected type '%s' and got '%s'"),
1377 pspec->name, g_type_name (pspec->g_type), g_type_name (gda_holder_get_g_type (h)));
1378 goto err;
1379 }
1380 }
1381 if (!h &&
1382 (!render_pspec ||
1383 (context->flags & (GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR |
1384 GDA_STATEMENT_SQL_PARAMS_AS_QMARK |
1385 GDA_STATEMENT_SQL_PARAMS_AS_UQMARK)))) {
1386 /* a real value is needed or @context->params_used needs to be correct, and no GdaHolder found */
1387 g_set_error (error, GDA_STATEMENT_ERROR, GDA_STATEMENT_PARAM_ERROR,
1388 _("Missing parameter '%s'"), pspec->name);
1389 goto err;
1390 }
1391 if (h) {
1392 /* keep track of the params used */
1393 context->params_used = g_slist_append (context->params_used, h);
1394
1395 if (! render_pspec) {
1396 const GValue *cvalue;
1397
1398 if (!gda_holder_is_valid (h)) {
1399 g_set_error (error, GDA_STATEMENT_ERROR, GDA_STATEMENT_PARAM_ERROR,
1400 _("Parameter '%s' is invalid"), pspec->name);
1401 goto err;
1402 }
1403 cvalue = gda_holder_get_value (h);
1404 if (cvalue) {
1405 str = context->render_value ((GValue*) cvalue, context, error);
1406 if (!str) goto err;
1407 g_string_append (string, str);
1408 g_free (str);
1409 if (is_null && gda_value_is_null (cvalue))
1410 *is_null = TRUE;
1411 }
1412 else {
1413 /* @h is set to a default value */
1414 g_string_append (string, "DEFAULT");
1415 if (is_default)
1416 *is_default = TRUE;
1417 }
1418 goto out;
1419 }
1420 }
1421
1422 /* no parameter found in context->params => insert an SQL parameter */
1423 if (context->flags & GDA_STATEMENT_SQL_PARAMS_AS_COLON) {
1424 gchar *str;
1425
1426 str = gda_text_to_alphanum (pspec->name);
1427 g_string_append_printf (string, ":%s", str);
1428 g_free (str);
1429 }
1430 else if (context->flags & (GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR |
1431 GDA_STATEMENT_SQL_PARAMS_AS_QMARK |
1432 GDA_STATEMENT_SQL_PARAMS_AS_UQMARK)) {
1433 if (context->flags & GDA_STATEMENT_SQL_PARAMS_AS_DOLLAR)
1434 g_string_append_printf (string, "$%d", g_slist_length (context->params_used));
1435 else if (context->flags & GDA_STATEMENT_SQL_PARAMS_AS_QMARK)
1436 g_string_append_printf (string, "?%d", g_slist_length (context->params_used));
1437 else
1438 g_string_append_c (string, '?');
1439 }
1440 else {
1441 GdaStatementSqlFlag flag = context->flags;
1442 gchar *quoted_pname;
1443
1444 if (! pspec->name) {
1445 g_set_error (error, GDA_STATEMENT_ERROR, GDA_STATEMENT_PARAM_ERROR,
1446 "%s", _("Unnamed parameter"));
1447 goto err;
1448 }
1449 quoted_pname = gda_sql_identifier_force_quotes (pspec->name);
1450
1451 if (! (flag & (GDA_STATEMENT_SQL_PARAMS_LONG | GDA_STATEMENT_SQL_PARAMS_SHORT))) {
1452 if (!expr->value || gda_value_is_null (expr->value) || strcmp (quoted_pname, pspec->name))
1453 flag = GDA_STATEMENT_SQL_PARAMS_LONG;
1454 else
1455 flag = GDA_STATEMENT_SQL_PARAMS_SHORT;
1456 }
1457
1458 if (flag & GDA_STATEMENT_SQL_PARAMS_LONG) {
1459 if (expr->value) {
1460 if (G_VALUE_TYPE (expr->value) == G_TYPE_STRING)
1461 str = g_value_dup_string (expr->value);
1462 else
1463 str = context->render_value (expr->value, context, error);
1464 if (!str) {
1465 g_free (quoted_pname);
1466 goto err;
1467 }
1468 g_string_append (string, str);
1469 g_free (str);
1470 }
1471 else
1472 g_string_append (string, "##");
1473
1474 g_string_append (string, " /* ");
1475 g_string_append_printf (string, "name:%s", quoted_pname);
1476 if (pspec->g_type) {
1477 str = gda_sql_identifier_force_quotes (gda_g_type_to_string (pspec->g_type));
1478 g_string_append_printf (string, " type:%s", str);
1479 g_free (str);
1480 }
1481 if (pspec->descr) {
1482 str = gda_sql_identifier_force_quotes (pspec->descr);
1483 g_string_append_printf (string, " descr:%s", str);
1484 g_free (str);
1485 }
1486 if (pspec->nullok)
1487 g_string_append (string, " nullok:true");
1488
1489 g_string_append (string, " */");
1490 }
1491 else {
1492 g_string_append (string, "##");
1493 g_string_append (string, pspec->name);
1494 if (pspec->g_type != GDA_TYPE_NULL) {
1495 g_string_append (string, "::");
1496 g_string_append (string, gda_g_type_to_string (pspec->g_type));
1497 if (pspec->nullok)
1498 g_string_append (string, "::NULL");
1499 }
1500 }
1501
1502 g_free (quoted_pname);
1503 }
1504
1505 out:
1506 str = string->str;
1507 g_string_free (string, FALSE);
1508 return str;
1509
1510 err:
1511 g_string_free (string, TRUE);
1512 return NULL;
1513 }
1514
1515 static gchar *
default_render_expr(GdaSqlExpr * expr,GdaSqlRenderingContext * context,gboolean * is_default,gboolean * is_null,GError ** error)1516 default_render_expr (GdaSqlExpr *expr, GdaSqlRenderingContext *context, gboolean *is_default,
1517 gboolean *is_null, GError **error)
1518 {
1519 GString *string;
1520 gchar *str = NULL;
1521
1522 g_return_val_if_fail (expr, NULL);
1523 g_return_val_if_fail (GDA_SQL_ANY_PART (expr)->type == GDA_SQL_ANY_EXPR, NULL);
1524
1525 if (is_default)
1526 *is_default = FALSE;
1527 if (is_null)
1528 *is_null = FALSE;
1529
1530 /* can't have:
1531 * - expr->cast_as && expr->param_spec
1532 */
1533 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (expr), error)) return NULL;
1534
1535 string = g_string_new ("");
1536 if (expr->param_spec) {
1537 str = context->render_param_spec (expr->param_spec, expr, context, is_default, is_null, error);
1538 if (!str) goto err;
1539 }
1540 else if (expr->value) {
1541 if (G_VALUE_TYPE (expr->value) == G_TYPE_STRING) {
1542 /* specific treatment for strings, see documentation about GdaSqlExpr's value attribute */
1543 const gchar *vstr;
1544 vstr = g_value_get_string (expr->value);
1545 if (vstr) {
1546 if (expr->value_is_ident) {
1547 gchar **ids_array;
1548 gint i;
1549 GString *string = NULL;
1550 GdaConnectionOptions cncoptions = 0;
1551 if (context->cnc)
1552 g_object_get (G_OBJECT (context->cnc), "options", &cncoptions, NULL);
1553 ids_array = gda_sql_identifier_split (vstr);
1554 if (!ids_array)
1555 str = g_strdup (vstr);
1556 else if (!(ids_array[0])) goto err;
1557 else {
1558 for (i = 0; ids_array[i]; i++) {
1559 gchar *tmp;
1560 if (!string)
1561 string = g_string_new ("");
1562 else
1563 g_string_append_c (string, '.');
1564 tmp = gda_sql_identifier_quote (ids_array[i], context->cnc,
1565 context->provider, FALSE,
1566 cncoptions & GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE);
1567 g_string_append (string, tmp);
1568 g_free (tmp);
1569 }
1570 g_strfreev (ids_array);
1571 str = g_string_free (string, FALSE);
1572 }
1573 }
1574 else {
1575 /* we don't have an identifier */
1576 if (!g_ascii_strcasecmp (vstr, "default")) {
1577 if (is_default)
1578 *is_default = TRUE;
1579 str = g_strdup ("DEFAULT");
1580 }
1581 else
1582 str = g_strdup (vstr);
1583 }
1584 }
1585 else {
1586 str = g_strdup ("NULL");
1587 if (is_null)
1588 *is_null = TRUE;
1589 }
1590 }
1591 if (!str) {
1592 /* use a GdaDataHandler to render the value as valid SQL */
1593 GdaDataHandler *dh;
1594 if (context->cnc) {
1595 GdaServerProvider *prov;
1596 prov = gda_connection_get_provider (context->cnc);
1597 dh = gda_server_provider_get_data_handler_g_type (prov, context->cnc,
1598 G_VALUE_TYPE (expr->value));
1599 if (!dh) goto err;
1600 }
1601 else
1602 dh = gda_data_handler_get_default (G_VALUE_TYPE (expr->value));
1603
1604 if (dh)
1605 str = gda_data_handler_get_sql_from_value (dh, expr->value);
1606 else
1607 str = gda_value_stringify (expr->value);
1608 if (!str) goto err;
1609 }
1610 }
1611 else if (expr->func) {
1612 str = context->render_function (GDA_SQL_ANY_PART (expr->func), context, error);
1613 if (!str) goto err;
1614 }
1615 else if (expr->cond) {
1616 gchar *tmp;
1617 tmp = context->render_operation (GDA_SQL_ANY_PART (expr->cond), context, error);
1618 if (!tmp) goto err;
1619 str = NULL;
1620 if (GDA_SQL_ANY_PART (expr)->parent) {
1621 if (GDA_SQL_ANY_PART (expr)->parent->type == GDA_SQL_ANY_STMT_SELECT) {
1622 GdaSqlStatementSelect *selst;
1623 selst = (GdaSqlStatementSelect*) (GDA_SQL_ANY_PART (expr)->parent);
1624 if ((expr == selst->where_cond) ||
1625 (expr == selst->having_cond))
1626 str = tmp;
1627 }
1628 else if (GDA_SQL_ANY_PART (expr)->parent->type == GDA_SQL_ANY_STMT_DELETE) {
1629 GdaSqlStatementDelete *delst;
1630 delst = (GdaSqlStatementDelete*) (GDA_SQL_ANY_PART (expr)->parent);
1631 if (expr == delst->cond)
1632 str = tmp;
1633 }
1634 else if (GDA_SQL_ANY_PART (expr)->parent->type == GDA_SQL_ANY_STMT_UPDATE) {
1635 GdaSqlStatementUpdate *updst;
1636 updst = (GdaSqlStatementUpdate*) (GDA_SQL_ANY_PART (expr)->parent);
1637 if (expr == updst->cond)
1638 str = tmp;
1639 }
1640 }
1641
1642 if (!str) {
1643 str = g_strconcat ("(", tmp, ")", NULL);
1644 g_free (tmp);
1645 }
1646 }
1647 else if (expr->select) {
1648 gchar *str1;
1649 if (GDA_SQL_ANY_PART (expr->select)->type == GDA_SQL_ANY_STMT_SELECT)
1650 str1 = context->render_select (GDA_SQL_ANY_PART (expr->select), context, error);
1651 else if (GDA_SQL_ANY_PART (expr->select)->type == GDA_SQL_ANY_STMT_COMPOUND)
1652 str1 = context->render_compound (GDA_SQL_ANY_PART (expr->select), context, error);
1653 else
1654 g_assert_not_reached ();
1655 if (!str1) goto err;
1656
1657 if (! GDA_SQL_ANY_PART (expr)->parent ||
1658 (GDA_SQL_ANY_PART (expr)->parent->type != GDA_SQL_ANY_SQL_FUNCTION)) {
1659 str = g_strconcat ("(", str1, ")", NULL);
1660 g_free (str1);
1661 }
1662 else
1663 str = str1;
1664 }
1665 else if (expr->case_s) {
1666 str = context->render_case (GDA_SQL_ANY_PART (expr->case_s), context, error);
1667 if (!str) goto err;
1668 }
1669 else {
1670 if (is_null)
1671 *is_null = TRUE;
1672 str = g_strdup ("NULL");
1673 }
1674
1675 if (!str) goto err;
1676
1677 if (expr->cast_as)
1678 g_string_append_printf (string, "CAST (%s AS %s)", str, expr->cast_as);
1679 else
1680 g_string_append (string, str);
1681 g_free (str);
1682
1683 str = string->str;
1684 g_string_free (string, FALSE);
1685 return str;
1686
1687 err:
1688 g_string_free (string, TRUE);
1689 return NULL;
1690 }
1691
1692 static gchar *
default_render_field(GdaSqlField * field,GdaSqlRenderingContext * context,GError ** error)1693 default_render_field (GdaSqlField *field, GdaSqlRenderingContext *context, GError **error)
1694 {
1695 g_return_val_if_fail (field, NULL);
1696 g_return_val_if_fail (GDA_SQL_ANY_PART (field)->type == GDA_SQL_ANY_SQL_FIELD, NULL);
1697
1698 /* can't have: field->field_name not a valid SQL identifier */
1699 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (field), error)) return NULL;
1700
1701 GdaConnectionOptions cncoptions = 0;
1702 if (context->cnc)
1703 g_object_get (G_OBJECT (context->cnc), "options", &cncoptions, NULL);
1704 return gda_sql_identifier_quote (field->field_name, context->cnc, context->provider,
1705 FALSE,
1706 cncoptions & GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE);
1707 }
1708
1709 static gchar *
default_render_table(GdaSqlTable * table,GdaSqlRenderingContext * context,GError ** error)1710 default_render_table (GdaSqlTable *table, GdaSqlRenderingContext *context, GError **error)
1711 {
1712 g_return_val_if_fail (table, NULL);
1713 g_return_val_if_fail (GDA_SQL_ANY_PART (table)->type == GDA_SQL_ANY_SQL_TABLE, NULL);
1714
1715 /* can't have: table->table_name not a valid SQL identifier */
1716 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (table), error)) return NULL;
1717
1718 gchar **ids_array;
1719 ids_array = gda_sql_identifier_split (table->table_name);
1720 if (!ids_array) {
1721 g_set_error (error, GDA_SQL_ERROR, GDA_SQL_STRUCTURE_CONTENTS_ERROR,
1722 "%s", _("Malformed table name"));
1723 return NULL;
1724 }
1725
1726 gint i;
1727 GString *string;
1728 GdaConnectionOptions cncoptions = 0;
1729 if (context->cnc)
1730 g_object_get (G_OBJECT (context->cnc), "options", &cncoptions, NULL);
1731 string = g_string_new ("");
1732 for (i = 0; ids_array [i]; i++) {
1733 gchar *tmp;
1734 tmp = gda_sql_identifier_quote (ids_array [i], context->cnc, context->provider,
1735 FALSE,
1736 cncoptions & GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE);
1737 g_free (ids_array [i]);
1738 ids_array [i] = tmp;
1739 if (i != 0)
1740 g_string_append_c (string, '.');
1741 g_string_append (string, ids_array [i]);
1742 }
1743 g_strfreev (ids_array);
1744 return g_string_free (string, FALSE);
1745 }
1746
1747 static gchar *
default_render_function(GdaSqlFunction * func,GdaSqlRenderingContext * context,GError ** error)1748 default_render_function (GdaSqlFunction *func, GdaSqlRenderingContext *context, GError **error)
1749 {
1750 GString *string;
1751 gchar *str;
1752 GSList *list;
1753
1754 g_return_val_if_fail (func, NULL);
1755 g_return_val_if_fail (GDA_SQL_ANY_PART (func)->type == GDA_SQL_ANY_SQL_FUNCTION, NULL);
1756
1757 /* can't have: func->function_name == NULL */
1758 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (func), error)) return NULL;
1759
1760 string = g_string_new (func->function_name);
1761 g_string_append (string, " (");
1762 for (list = func->args_list; list; list = list->next) {
1763 if (list != func->args_list)
1764 g_string_append (string, ", ");
1765 str = context->render_expr (list->data, context, NULL, NULL, error);
1766 if (!str) goto err;
1767 if (((GdaSqlExpr*) list->data)->select)
1768 g_string_append_c (string, '(');
1769 g_string_append (string, str);
1770 if (((GdaSqlExpr*) list->data)->select)
1771 g_string_append_c (string, ')');
1772 g_free (str);
1773 }
1774 g_string_append_c (string, ')');
1775
1776 str = string->str;
1777 g_string_free (string, FALSE);
1778 return str;
1779
1780 err:
1781 g_string_free (string, TRUE);
1782 return NULL;
1783 }
1784
1785 static gchar *
default_render_operation(GdaSqlOperation * op,GdaSqlRenderingContext * context,GError ** error)1786 default_render_operation (GdaSqlOperation *op, GdaSqlRenderingContext *context, GError **error)
1787 {
1788 gchar *str;
1789 GSList *list;
1790 GSList *sql_list; /* list of SqlOperand */
1791 GString *string;
1792 gchar *multi_op = NULL;
1793
1794 typedef struct {
1795 gchar *sql;
1796 gboolean is_null;
1797 gboolean is_default;
1798 gboolean is_composed;
1799 } SqlOperand;
1800 #define SQL_OPERAND(x) ((SqlOperand*)(x))
1801
1802 g_return_val_if_fail (op, NULL);
1803 g_return_val_if_fail (GDA_SQL_ANY_PART (op)->type == GDA_SQL_ANY_SQL_OPERATION, NULL);
1804
1805 /* can't have:
1806 * - op->operands == NULL
1807 * - incorrect number of operands
1808 */
1809 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (op), error)) return NULL;
1810
1811 /* render operands */
1812 for (list = op->operands, sql_list = NULL; list; list = list->next) {
1813 SqlOperand *sqlop = g_new0 (SqlOperand, 1);
1814 GdaSqlExpr *expr = (GdaSqlExpr*) list->data;
1815 str = context->render_expr (expr, context, &(sqlop->is_default), &(sqlop->is_null), error);
1816 if (!str) {
1817 g_free (sqlop);
1818 goto out;
1819 }
1820 sqlop->sql = str;
1821 if (expr->case_s || expr->select)
1822 sqlop->is_composed = TRUE;
1823 sql_list = g_slist_prepend (sql_list, sqlop);
1824 }
1825 sql_list = g_slist_reverse (sql_list);
1826
1827 str = NULL;
1828 switch (op->operator_type) {
1829 case GDA_SQL_OPERATOR_TYPE_EQ:
1830 if (SQL_OPERAND (sql_list->next->data)->is_null)
1831 str = g_strdup_printf ("%s IS NULL", SQL_OPERAND (sql_list->data)->sql);
1832 else
1833 str = g_strdup_printf ("%s = %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1834 break;
1835 case GDA_SQL_OPERATOR_TYPE_IS:
1836 str = g_strdup_printf ("%s IS %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1837 break;
1838 case GDA_SQL_OPERATOR_TYPE_LIKE:
1839 str = g_strdup_printf ("%s LIKE %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1840 break;
1841 case GDA_SQL_OPERATOR_TYPE_NOTLIKE:
1842 str = g_strdup_printf ("%s NOT LIKE %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1843 break;
1844 case GDA_SQL_OPERATOR_TYPE_ILIKE:
1845 str = g_strdup_printf ("%s ILIKE %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1846 break;
1847 case GDA_SQL_OPERATOR_TYPE_NOTILIKE:
1848 str = g_strdup_printf ("%s NOT ILIKE %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1849 break;
1850 case GDA_SQL_OPERATOR_TYPE_GT:
1851 str = g_strdup_printf ("%s > %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1852 break;
1853 case GDA_SQL_OPERATOR_TYPE_LT:
1854 str = g_strdup_printf ("%s < %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1855 break;
1856 case GDA_SQL_OPERATOR_TYPE_GEQ:
1857 str = g_strdup_printf ("%s >= %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1858 break;
1859 case GDA_SQL_OPERATOR_TYPE_LEQ:
1860 str = g_strdup_printf ("%s <= %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1861 break;
1862 case GDA_SQL_OPERATOR_TYPE_DIFF:
1863 str = g_strdup_printf ("%s != %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1864 break;
1865 case GDA_SQL_OPERATOR_TYPE_REGEXP:
1866 str = g_strdup_printf ("%s ~ %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1867 break;
1868 case GDA_SQL_OPERATOR_TYPE_REGEXP_CI:
1869 str = g_strdup_printf ("%s ~* %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1870 break;
1871 case GDA_SQL_OPERATOR_TYPE_NOT_REGEXP:
1872 str = g_strdup_printf ("%s !~ %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1873 break;
1874 case GDA_SQL_OPERATOR_TYPE_NOT_REGEXP_CI:
1875 str = g_strdup_printf ("%s !~* %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1876 break;
1877 case GDA_SQL_OPERATOR_TYPE_SIMILAR:
1878 str = g_strdup_printf ("%s SIMILAR TO %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1879 break;
1880 case GDA_SQL_OPERATOR_TYPE_REM:
1881 str = g_strdup_printf ("%s %% %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1882 break;
1883 case GDA_SQL_OPERATOR_TYPE_DIV:
1884 str = g_strdup_printf ("%s / %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1885 break;
1886 case GDA_SQL_OPERATOR_TYPE_BITAND:
1887 str = g_strdup_printf ("%s & %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1888 break;
1889 case GDA_SQL_OPERATOR_TYPE_BITOR:
1890 str = g_strdup_printf ("%s | %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1891 break;
1892 case GDA_SQL_OPERATOR_TYPE_BETWEEN:
1893 str = g_strdup_printf ("%s BETWEEN %s AND %s", SQL_OPERAND (sql_list->data)->sql,
1894 SQL_OPERAND (sql_list->next->data)->sql,
1895 SQL_OPERAND (sql_list->next->next->data)->sql);
1896 break;
1897 case GDA_SQL_OPERATOR_TYPE_ISNULL:
1898 str = g_strdup_printf ("%s IS NULL", SQL_OPERAND (sql_list->data)->sql);
1899 break;
1900 case GDA_SQL_OPERATOR_TYPE_ISNOTNULL:
1901 str = g_strdup_printf ("%s IS NOT NULL", SQL_OPERAND (sql_list->data)->sql);
1902 break;
1903 case GDA_SQL_OPERATOR_TYPE_BITNOT:
1904 str = g_strdup_printf ("~ %s", SQL_OPERAND (sql_list->data)->sql);
1905 break;
1906 case GDA_SQL_OPERATOR_TYPE_NOT:
1907 str = g_strdup_printf ("NOT %s", SQL_OPERAND (sql_list->data)->sql);
1908 break;
1909 case GDA_SQL_OPERATOR_TYPE_IN:
1910 case GDA_SQL_OPERATOR_TYPE_NOTIN: {
1911 gboolean add_p = TRUE;
1912 if (sql_list->next && !(sql_list->next->next) &&
1913 *(SQL_OPERAND (sql_list->next->data)->sql)=='(')
1914 add_p = FALSE;
1915
1916 string = g_string_new (SQL_OPERAND (sql_list->data)->sql);
1917 if (op->operator_type == GDA_SQL_OPERATOR_TYPE_IN)
1918 g_string_append (string, " IN ");
1919 else
1920 g_string_append (string, " NOT IN ");
1921 if (add_p)
1922 g_string_append_c (string, '(');
1923 for (list = sql_list->next; list; list = list->next) {
1924 if (list != sql_list->next)
1925 g_string_append (string, ", ");
1926 g_string_append (string, SQL_OPERAND (list->data)->sql);
1927 }
1928 if (add_p)
1929 g_string_append_c (string, ')');
1930 str = string->str;
1931 g_string_free (string, FALSE);
1932 break;
1933 }
1934 case GDA_SQL_OPERATOR_TYPE_CONCAT:
1935 multi_op = "||";
1936 break;
1937 case GDA_SQL_OPERATOR_TYPE_PLUS:
1938 multi_op = "+";
1939 break;
1940 case GDA_SQL_OPERATOR_TYPE_MINUS:
1941 multi_op = "-";
1942 break;
1943 case GDA_SQL_OPERATOR_TYPE_STAR:
1944 multi_op = "*";
1945 break;
1946 case GDA_SQL_OPERATOR_TYPE_AND:
1947 multi_op = "AND";
1948 break;
1949 case GDA_SQL_OPERATOR_TYPE_OR:
1950 multi_op = "OR";
1951 break;
1952 case GDA_SQL_OPERATOR_TYPE_GLOB:
1953 str = g_strdup_printf ("%s GLOB %s", SQL_OPERAND (sql_list->data)->sql, SQL_OPERAND (sql_list->next->data)->sql);
1954 break;
1955 default:
1956 g_assert_not_reached ();
1957 break;
1958 }
1959
1960 if (multi_op) {
1961 if (!sql_list->next) {
1962 /* 1 operand only */
1963 string = g_string_new ("");
1964 g_string_append_printf (string, "%s %s", multi_op, SQL_OPERAND (sql_list->data)->sql);
1965 }
1966 else {
1967 /* 2 or more operands */
1968 if (SQL_OPERAND (sql_list->data)->is_composed) {
1969 string = g_string_new ("(");
1970 g_string_append (string, SQL_OPERAND (sql_list->data)->sql);
1971 g_string_append_c (string, ')');
1972 }
1973 else
1974 string = g_string_new (SQL_OPERAND (sql_list->data)->sql);
1975 for (list = sql_list->next; list; list = list->next) {
1976 g_string_append_printf (string, " %s ", multi_op);
1977 if (SQL_OPERAND (list->data)->is_composed) {
1978 g_string_append_c (string, '(');
1979 g_string_append (string, SQL_OPERAND (list->data)->sql);
1980 g_string_append_c (string, ')');
1981 }
1982 else
1983 g_string_append (string, SQL_OPERAND (list->data)->sql);
1984 }
1985 }
1986 str = string->str;
1987 g_string_free (string, FALSE);
1988 }
1989
1990 out:
1991 for (list = sql_list; list; list = list->next) {
1992 g_free (((SqlOperand*)list->data)->sql);
1993 g_free (list->data);
1994 }
1995 g_slist_free (sql_list);
1996
1997 return str;
1998 }
1999
2000 static gchar *
default_render_case(GdaSqlCase * case_s,GdaSqlRenderingContext * context,GError ** error)2001 default_render_case (GdaSqlCase *case_s, GdaSqlRenderingContext *context, GError **error)
2002 {
2003 GString *string;
2004 gchar *str;
2005 GSList *wlist, *tlist;
2006
2007 g_return_val_if_fail (case_s, NULL);
2008 g_return_val_if_fail (GDA_SQL_ANY_PART (case_s)->type == GDA_SQL_ANY_SQL_CASE, NULL);
2009
2010 /* can't have:
2011 * - case_s->when_expr_list == NULL
2012 * - g_slist_length (sc->when_expr_list) != g_slist_length (sc->then_expr_list)
2013 */
2014 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (case_s), error)) return NULL;
2015
2016 string = g_string_new ("CASE");
2017 if (case_s->base_expr) {
2018 g_string_append_c (string, ' ');
2019 str = context->render_expr (case_s->base_expr, context, NULL, NULL, error);
2020 if (!str) goto err;
2021 g_string_append (string, str);
2022 g_free (str);
2023 }
2024
2025 for (wlist = case_s->when_expr_list, tlist = case_s->then_expr_list;
2026 wlist && tlist;
2027 wlist = wlist->next, tlist = tlist->next) {
2028 g_string_append (string, " WHEN ");
2029 str = context->render_expr ((GdaSqlExpr*) wlist->data, context, NULL, NULL, error);
2030 if (!str) goto err;
2031 g_string_append (string, str);
2032 g_free (str);
2033 g_string_append (string, " THEN ");
2034 str = context->render_expr ((GdaSqlExpr*) tlist->data, context, NULL, NULL, error);
2035 if (!str) goto err;
2036 g_string_append (string, str);
2037 g_free (str);
2038 }
2039
2040 if (case_s->else_expr) {
2041 g_string_append (string, " ELSE ");
2042 str = context->render_expr (case_s->else_expr, context, NULL, NULL, error);
2043 if (!str) goto err;
2044 g_string_append (string, str);
2045 g_free (str);
2046 }
2047
2048 g_string_append (string, " END");
2049
2050 str = string->str;
2051 g_string_free (string, FALSE);
2052 return str;
2053
2054 err:
2055 g_string_free (string, TRUE);
2056 return NULL;
2057 }
2058
2059 static gboolean
alias_is_quoted(const gchar * alias)2060 alias_is_quoted (const gchar *alias)
2061 {
2062 g_assert (alias);
2063 if ((*alias == '\'') || (*alias == '"'))
2064 return TRUE;
2065 else
2066 return FALSE;
2067 }
2068
2069 static gchar *
default_render_select_field(GdaSqlSelectField * field,GdaSqlRenderingContext * context,GError ** error)2070 default_render_select_field (GdaSqlSelectField *field, GdaSqlRenderingContext *context, GError **error)
2071 {
2072 GString *string;
2073 gchar *str;
2074
2075 g_return_val_if_fail (field, NULL);
2076 g_return_val_if_fail (GDA_SQL_ANY_PART (field)->type == GDA_SQL_ANY_SQL_SELECT_FIELD, NULL);
2077
2078 /* can't have: field->expr == NULL */
2079 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (field), error)) return NULL;
2080
2081 string = g_string_new ("");
2082 str = context->render_expr (field->expr, context, NULL, NULL, error);
2083 if (!str) goto err;
2084 g_string_append (string, str);
2085 g_free (str);
2086
2087 if (field->as) {
2088 if (! alias_is_quoted (field->as)) {
2089 GdaConnectionOptions cncoptions = 0;
2090 gchar *tmp;
2091 if (context->cnc)
2092 g_object_get (G_OBJECT (context->cnc), "options", &cncoptions, NULL);
2093 tmp = gda_sql_identifier_quote (field->as, context->cnc,
2094 context->provider, FALSE,
2095 cncoptions & GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE);
2096 g_string_append_printf (string, " AS %s", tmp);
2097 g_free (tmp);
2098 }
2099 else
2100 g_string_append_printf (string, " AS %s", field->as);
2101 }
2102
2103 str = string->str;
2104 g_string_free (string, FALSE);
2105 return str;
2106
2107 err:
2108 g_string_free (string, TRUE);
2109 return NULL;
2110 }
2111
2112 static gchar *
default_render_select_target(GdaSqlSelectTarget * target,GdaSqlRenderingContext * context,GError ** error)2113 default_render_select_target (GdaSqlSelectTarget *target, GdaSqlRenderingContext *context, GError **error)
2114 {
2115 GString *string;
2116 gchar *str;
2117
2118 g_return_val_if_fail (target, NULL);
2119 g_return_val_if_fail (GDA_SQL_ANY_PART (target)->type == GDA_SQL_ANY_SQL_SELECT_TARGET, NULL);
2120
2121 /* can't have: target->expr == NULL */
2122 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (target), error)) return NULL;
2123
2124 if (! target->expr->value || (G_VALUE_TYPE (target->expr->value) != G_TYPE_STRING)) {
2125 str = context->render_expr (target->expr, context, NULL, NULL, error);
2126 if (!str)
2127 return NULL;
2128 string = g_string_new (str);
2129 g_free (str);
2130 }
2131 else {
2132 gboolean tmp;
2133 tmp = target->expr->value_is_ident;
2134 target->expr->value_is_ident = TRUE;
2135 str = context->render_expr (target->expr, context, NULL, NULL, error);
2136 target->expr->value_is_ident = tmp;
2137 string = g_string_new (str);
2138 g_free (str);
2139 }
2140
2141 if (target->as) {
2142 if (! alias_is_quoted (target->as)) {
2143 GdaConnectionOptions cncoptions = 0;
2144 gchar *tmp;
2145 if (context->cnc)
2146 g_object_get (G_OBJECT (context->cnc), "options", &cncoptions, NULL);
2147 tmp = gda_sql_identifier_quote (target->as, context->cnc,
2148 context->provider, FALSE,
2149 cncoptions & GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE);
2150 g_string_append_printf (string, " AS %s", tmp);
2151 g_free (tmp);
2152 }
2153 else
2154 g_string_append_printf (string, " AS %s", target->as);
2155 }
2156
2157 str = string->str;
2158 g_string_free (string, FALSE);
2159 return str;
2160 }
2161
2162 static gchar *
default_render_select_join(GdaSqlSelectJoin * join,GdaSqlRenderingContext * context,GError ** error)2163 default_render_select_join (GdaSqlSelectJoin *join, GdaSqlRenderingContext *context, GError **error)
2164 {
2165 GString *string;
2166 gchar *str;
2167 gboolean pretty = context->flags & GDA_STATEMENT_SQL_PRETTY;
2168
2169 g_return_val_if_fail (join, NULL);
2170 g_return_val_if_fail (GDA_SQL_ANY_PART (join)->type == GDA_SQL_ANY_SQL_SELECT_JOIN, NULL);
2171
2172 /* can't have:
2173 * - join->expr && join->use
2174 * - (join->type == GDA_SQL_SELECT_JOIN_CROSS) && (join->expr || join->use)
2175 */
2176 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (join), error)) return NULL;
2177
2178 switch (join->type) {
2179 case GDA_SQL_SELECT_JOIN_CROSS:
2180 if (pretty)
2181 string = g_string_new (",\n\t");
2182 else
2183 string = g_string_new (",");
2184 break;
2185 case GDA_SQL_SELECT_JOIN_NATURAL:
2186 if (pretty)
2187 string = g_string_new ("\n\tNATURAL JOIN");
2188 else
2189 string = g_string_new ("NATURAL JOIN");
2190 break;
2191 case GDA_SQL_SELECT_JOIN_INNER:
2192 if (pretty)
2193 string = g_string_new ("\n\tINNER JOIN");
2194 else
2195 string = g_string_new ("INNER JOIN");
2196 break;
2197 case GDA_SQL_SELECT_JOIN_LEFT:
2198 if (pretty)
2199 string = g_string_new ("\n\tLEFT JOIN");
2200 else
2201 string = g_string_new ("LEFT JOIN");
2202 break;
2203 case GDA_SQL_SELECT_JOIN_RIGHT:
2204 if (pretty)
2205 string = g_string_new ("\n\tRIGHT JOIN");
2206 else
2207 string = g_string_new ("RIGHT JOIN");
2208 break;
2209 case GDA_SQL_SELECT_JOIN_FULL:
2210 if (pretty)
2211 string = g_string_new ("\n\tFULL JOIN");
2212 else
2213 string = g_string_new ("FULL JOIN");
2214 break;
2215 default:
2216 g_assert_not_reached ();
2217 }
2218
2219 /* find joinned target */
2220 GdaSqlSelectFrom *from = (GdaSqlSelectFrom *) GDA_SQL_ANY_PART (join)->parent;
2221 if (!from || (GDA_SQL_ANY_PART (from)->type != GDA_SQL_ANY_SQL_SELECT_FROM)) {
2222 g_set_error (error, GDA_SQL_ERROR, GDA_SQL_STRUCTURE_CONTENTS_ERROR,
2223 "%s", _("Join is not in a FROM statement"));
2224 goto err;
2225 }
2226 GdaSqlSelectTarget *target;
2227 target = g_slist_nth_data (from->targets, join->position);
2228 if (!target || (GDA_SQL_ANY_PART (target)->type != GDA_SQL_ANY_SQL_SELECT_TARGET)) {
2229 g_set_error (error, GDA_SQL_ERROR, GDA_SQL_STRUCTURE_CONTENTS_ERROR,
2230 "%s", _("Could not find target the join is for"));
2231 goto err;
2232 }
2233 str = context->render_select_target (GDA_SQL_ANY_PART (target), context, error);
2234 if (!str) goto err;
2235
2236 g_string_append_c (string, ' ');
2237 g_string_append (string, str);
2238 g_free (str);
2239
2240 if (join->expr) {
2241 g_string_append (string, " ON (");
2242 str = context->render_expr (join->expr, context, NULL, NULL, error);
2243 if (!str) goto err;
2244 g_string_append (string, str);
2245 g_free (str);
2246 g_string_append_c (string, ')');
2247 }
2248 else if (join->use) {
2249 GSList *list;
2250 g_string_append (string, " USING (");
2251 for (list = join->use; list; list = list->next) {
2252 if (list != join->use)
2253 g_string_append (string, ", ");
2254 str = context->render_field (GDA_SQL_ANY_PART (list->data), context, error);
2255 if (!str) goto err;
2256 g_string_append (string, str);
2257 g_free (str);
2258 }
2259 g_string_append_c (string, ')');
2260 }
2261
2262 str = string->str;
2263 g_string_free (string, FALSE);
2264 return str;
2265
2266 err:
2267 g_string_free (string, TRUE);
2268 return NULL;
2269 }
2270
2271 static GdaSqlSelectJoin *
find_join_for_pos(GSList * joins_list,gint pos)2272 find_join_for_pos (GSList *joins_list, gint pos)
2273 {
2274 GSList *list;
2275 for (list = joins_list; list; list = list->next) {
2276 if (((GdaSqlSelectJoin*) list->data)->position == pos)
2277 return (GdaSqlSelectJoin*) list->data;
2278 }
2279 return NULL;
2280 }
2281
2282 static gchar *
default_render_select_from(GdaSqlSelectFrom * from,GdaSqlRenderingContext * context,GError ** error)2283 default_render_select_from (GdaSqlSelectFrom *from, GdaSqlRenderingContext *context, GError **error)
2284 {
2285 GString *string;
2286 gchar *str;
2287 GSList *tlist;
2288 gint i;
2289 gboolean pretty = context->flags & GDA_STATEMENT_SQL_PRETTY;
2290
2291 g_return_val_if_fail (from, NULL);
2292 g_return_val_if_fail (GDA_SQL_ANY_PART (from)->type == GDA_SQL_ANY_SQL_SELECT_FROM, NULL);
2293
2294 /* can't have: from->targets == NULL */
2295 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (from), error)) return NULL;
2296
2297 string = g_string_new ("FROM ");
2298 for (tlist = from->targets, i = 0; tlist; tlist = tlist->next, i++) {
2299 GdaSqlSelectJoin *join = NULL;
2300 if (tlist != from->targets)
2301 join = find_join_for_pos (from->joins, i);
2302
2303 if (join) {
2304 str = context->render_select_join (GDA_SQL_ANY_PART (join), context, error);
2305 if (!str) goto err;
2306 if (!pretty)
2307 g_string_append_c (string, ' ');
2308 g_string_append (string, str);
2309 g_free (str);
2310 if (!pretty)
2311 g_string_append_c (string, ' ');
2312 }
2313 else {
2314 if (tlist != from->targets) {
2315 if (pretty)
2316 g_string_append (string, ",\n\t");
2317 else
2318 g_string_append (string, ", ");
2319 }
2320 str = context->render_select_target (GDA_SQL_ANY_PART (tlist->data), context, error);
2321 if (!str) goto err;
2322 g_string_append (string, str);
2323 g_free (str);
2324 }
2325 }
2326
2327 str = string->str;
2328 g_string_free (string, FALSE);
2329 return str;
2330
2331 err:
2332 g_string_free (string, TRUE);
2333 return NULL;
2334 }
2335
2336 static gchar *
default_render_select_order(GdaSqlSelectOrder * order,GdaSqlRenderingContext * context,GError ** error)2337 default_render_select_order (GdaSqlSelectOrder *order, GdaSqlRenderingContext *context, GError **error)
2338 {
2339 GString *string;
2340 gchar *str;
2341
2342 g_return_val_if_fail (order, NULL);
2343 g_return_val_if_fail (GDA_SQL_ANY_PART (order)->type == GDA_SQL_ANY_SQL_SELECT_ORDER, NULL);
2344
2345 /* can't have: order->expr == NULL */
2346 if (!gda_sql_any_part_check_structure (GDA_SQL_ANY_PART (order), error)) return NULL;
2347
2348 string = g_string_new ("");
2349 str = context->render_expr (order->expr, context, NULL, NULL, error);
2350 if (!str) goto err;
2351 g_string_append (string, str);
2352 g_free (str);
2353
2354 if (order->collation_name)
2355 g_string_append_printf (string, " COLLATE %s", order->collation_name);
2356
2357 if (order->asc)
2358 g_string_append (string, " ASC");
2359 else
2360 g_string_append (string, " DESC");
2361
2362 str = string->str;
2363 g_string_free (string, FALSE);
2364 return str;
2365
2366 err:
2367 g_string_free (string, TRUE);
2368 return NULL;
2369 }
2370