gda_sql_statement_new ()

GdaSqlStatement *
gda_sql_statement_new (GdaSqlStatementType type);

Use this function to create a GdaSqlStatement of the specified type type.

gda_sql_statement_copy ()

GdaSqlStatement *
gda_sql_statement_copy (GdaSqlStatement *stmt);

Creates a copy of stmt .

gda_sql_statement_free ()

void
gda_sql_statement_free (GdaSqlStatement *stmt);

Releases any memory associated to stmt .

gda_sql_statement_serialize ()

gchar *
gda_sql_statement_serialize (GdaSqlStatement *stmt);

Creates a string representation of stmt .

gda_sql_statement_type_to_string ()

const gchar *
gda_sql_statement_type_to_string (GdaSqlStatementType type);

Converts a GdaSqlStatementType to a string, see also gda_sql_statement_string_to_type()

gda_sql_statement_string_to_type ()

GdaSqlStatementType
gda_sql_statement_string_to_type (const gchar *type);

Converts a string to a GdaSqlStatementType value, see also gda_sql_statement_type_to_string()

gda_sql_statement_check_structure ()

gboolean
gda_sql_statement_check_structure (GdaSqlStatement *stmt,
                                   GError **error);

Checks for any error in stmt 's structure to make sure the statement is valid (for example a SELECT statement must at least return a column, a DELETE statement must specify which table is targeted).

gda_sql_statement_check_validity ()

gboolean
gda_sql_statement_check_validity (GdaSqlStatement *stmt,
                                  GdaConnection *cnc,
                                  GError **error);

If cnc is not NULL, then checks that all the database objects referenced in the statement actually exist in the connection's database (for example the table being updated in a UPDATE statement must exist in the connection's database for the check to succeed). This method fills the stmt ->validity_meta_struct attribute.

If cnc is NULL, then remove any information from a previous call to this method stored in stmt . In this case, the stmt ->validity_meta_struct attribute is cleared.

Also note that some parts of stmt may be modified: for example leading and trailing spaces in aliases or objects names will be removed.

gda_sql_statement_check_validity_m ()

gboolean
gda_sql_statement_check_validity_m (GdaSqlStatement *stmt,
                                    GdaMetaStruct *mstruct,
                                    GError **error);

If mstruct is not NULL, then checks that all the database objects referenced in the statement i actually referenced in mstruct (for example the table being updated in a UPDATE statement must exist in the connection's database for the check to succeed). This method sets the stmt ->validity_meta_struct attribute to mstruct .

If mstruct is NULL, then remove any information from a previous call to this method stored in stmt . In this case, the stmt ->validity_meta_struct attribute is cleared.

Also note that some parts of stmt may be modified: for example leading and trailing spaces in aliases or objects names will be removed.

Since: 4.2

gda_sql_statement_check_clean ()

void
gda_sql_statement_check_clean (GdaSqlStatement *stmt);

Cleans any data set by a previous call to gda_sql_statement_check_validity().

gda_sql_statement_normalize ()

gboolean
gda_sql_statement_normalize (GdaSqlStatement *stmt,
                             GdaConnection *cnc,
                             GError **error);

"Normalizes" (in place) some parts of stmt , which means stmt may be modified. At the moment any "*" field in a SELECT statement will be replaced by one GdaSqlSelectField structure for each field in the referenced table.

GDA_SQL_ANY_PART()

#define GDA_SQL_ANY_PART(x) ((GdaSqlAnyPart*)(x))

GdaSqlForeachFunc ()

gboolean
(*GdaSqlForeachFunc) (GdaSqlAnyPart *part,
                      gpointer data,
                      GError **error);

Specifies the type of functions passed to gda_sql_any_part_foreach().

[skip]

gda_sql_any_part_foreach ()

gboolean
gda_sql_any_part_foreach (GdaSqlAnyPart *node,
                          GdaSqlForeachFunc func,
                          gpointer data,
                          GError **error);

Calls a function for each element of a GdaSqlAnyPart node

gda_sql_statement_unknown_take_expressions ()

void
gda_sql_statement_unknown_take_expressions
                               (GdaSqlStatement *stmt,
                                GSList *expressions);

Sets stmt 's list of expressions

expressions 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_trans_take_mode ()

void
gda_sql_statement_trans_take_mode (GdaSqlStatement *stmt,
                                   GValue *value);

Sets the model of the transaction

value 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_trans_take_name ()

void
gda_sql_statement_trans_take_name (GdaSqlStatement *stmt,
                                   GValue *value);

Sets the name of the transaction

value 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_trans_set_isol_level ()

void
gda_sql_statement_trans_set_isol_level
                               (GdaSqlStatement *stmt,
                                GdaTransactionIsolation level);

gda_sql_statement_select_take_distinct ()

void
gda_sql_statement_select_take_distinct
                               (GdaSqlStatement *stmt,
                                gboolean distinct,
                                GdaSqlExpr *distinct_expr);

Sets the DISTINCT clause of stmt .

distinct_expr 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_select_take_expr_list ()

void
gda_sql_statement_select_take_expr_list
                               (GdaSqlStatement *stmt,
                                GSList *expr_list);

Sets list of expressions selected by stmt

expr_list 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_select_take_from ()

void
gda_sql_statement_select_take_from (GdaSqlStatement *stmt,
                                    GdaSqlSelectFrom *from);

Sets the FROM clause of stmt

from 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_select_take_where_cond ()

void
gda_sql_statement_select_take_where_cond
                               (GdaSqlStatement *stmt,
                                GdaSqlExpr *expr);

Sets the WHERE clause of stmt

expr 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_select_take_group_by ()

void
gda_sql_statement_select_take_group_by
                               (GdaSqlStatement *stmt,
                                GSList *group_by);

Sets the GROUP BY clause of stmt

group_by 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_select_take_having_cond ()

void
gda_sql_statement_select_take_having_cond
                               (GdaSqlStatement *stmt,
                                GdaSqlExpr *expr);

Sets the HAVING clause of stmt

expr 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_select_take_order_by ()

void
gda_sql_statement_select_take_order_by
                               (GdaSqlStatement *stmt,
                                GSList *order_by);

Sets the ORDER BY clause of stmt

order_by 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_select_take_limits ()

void
gda_sql_statement_select_take_limits (GdaSqlStatement *stmt,
                                      GdaSqlExpr *count,
                                      GdaSqlExpr *offset);

Sets the LIMIT clause of stmt

count and offset 's responsibility are transferred to stmt (which means stmt is then responsible for freeing them when no longer needed).

gda_sql_statement_insert_take_table_name ()

void
gda_sql_statement_insert_take_table_name
                               (GdaSqlStatement *stmt,
                                GValue *value);

Sets the name of the table to insert into in stmt . value 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_insert_take_on_conflict ()

void
gda_sql_statement_insert_take_on_conflict
                               (GdaSqlStatement *stmt,
                                GValue *value);

Sets the name of the resolution conflict algorithm used by stmt . value 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_insert_take_fields_list ()

void
gda_sql_statement_insert_take_fields_list
                               (GdaSqlStatement *stmt,
                                GSList *list);

Sets the list of fields for which values will be specified in stmt . list 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_insert_take_1_values_list ()

void
gda_sql_statement_insert_take_1_values_list
                               (GdaSqlStatement *stmt,
                                GSList *list);

Sets a list of list of values to be inserted by stmt . list 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_insert_take_extra_values_list ()

void
gda_sql_statement_insert_take_extra_values_list
                               (GdaSqlStatement *stmt,
                                GSList *list);

gda_sql_statement_insert_take_select ()

void
gda_sql_statement_insert_take_select (GdaSqlStatement *stmt,
                                      GdaSqlStatement *select);

Specifies a SELECT statement, the values inserted will be the result set of select . select 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_delete_take_table_name ()

void
gda_sql_statement_delete_take_table_name
                               (GdaSqlStatement *stmt,
                                GValue *value);

Sets the name of the table to delete from in stmt . value 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_delete_take_condition ()

void
gda_sql_statement_delete_take_condition
                               (GdaSqlStatement *stmt,
                                GdaSqlExpr *cond);

Sets the WHERE condition of stmt . cond 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_update_take_table_name ()

void
gda_sql_statement_update_take_table_name
                               (GdaSqlStatement *stmt,
                                GValue *value);

Sets the name of the table to delete from in stmt .

value 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_update_take_on_conflict ()

void
gda_sql_statement_update_take_on_conflict
                               (GdaSqlStatement *stmt,
                                GValue *value);

Sets the name of the resolution conflict algorithm used by stmt . value 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_update_take_condition ()

void
gda_sql_statement_update_take_condition
                               (GdaSqlStatement *stmt,
                                GdaSqlExpr *cond);

Sets the WHERE clause of stmt

expr 's ownership is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_statement_update_take_set_value ()

void
gda_sql_statement_update_take_set_value
                               (GdaSqlStatement *stmt,
                                GValue *fname,
                                GdaSqlExpr *expr);

Specifies that the field named fname will be updated with the expression expr .

fname and expr 's responsibility are transferred to stmt (which means stmt is then responsible for freeing them when no longer needed).

gda_sql_statement_compound_set_type ()

void
gda_sql_statement_compound_set_type (GdaSqlStatement *stmt,
                                     GdaSqlStatementCompoundType type);

Specifies stmt 's type of compound

gda_sql_statement_compound_take_stmt ()

void
gda_sql_statement_compound_take_stmt (GdaSqlStatement *stmt,
                                      GdaSqlStatement *s);

Adds the s sub-statement to the stmt compound statement. s 's reference is transferred to stmt (which means stmt is then responsible for freeing it when no longer needed).

gda_sql_expr_new ()

GdaSqlExpr *
gda_sql_expr_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlField structure, using parent as its parent part.

gda_sql_expr_free ()

void
gda_sql_expr_free (GdaSqlExpr *expr);

Frees a GdaSqlExpr structure and its members.

gda_sql_expr_copy ()

GdaSqlExpr *
gda_sql_expr_copy (GdaSqlExpr *expr);

Creates a new GdaSqlExpr structure initiated with the values stored in expr .

gda_sql_expr_serialize ()

gchar *
gda_sql_expr_serialize (GdaSqlExpr *expr);

Creates a new string representation of the SQL expression. You need to free the returned string using g_free();

gda_sql_expr_take_select ()

void
gda_sql_expr_take_select (GdaSqlExpr *expr,
                          GdaSqlStatement *stmt);

Sets the expression's parent to the GdaSqlStatementSelect held by stmt . After calling this function stmt is freed.

gda_sql_param_spec_new ()

GdaSqlParamSpec *
gda_sql_param_spec_new (GValue *simple_spec);

value must contain a string representing a variable, see the documentation associated to the GdaSqlParser object.

value is destroyed by this function.

gda_sql_param_spec_copy ()

GdaSqlParamSpec *
gda_sql_param_spec_copy (GdaSqlParamSpec *pspec);

Creates a copy of pspec .

gda_sql_param_spec_take_name ()

void
gda_sql_param_spec_take_name (GdaSqlParamSpec *pspec,
                              GValue *value);

Sets pspec 's name. value 's ownership is transferred to pspec (which means pspec is then responsible for freeing it when no longer needed).

gda_sql_param_spec_take_type ()

void
gda_sql_param_spec_take_type (GdaSqlParamSpec *pspec,
                              GValue *value);

Sets pspec 's data type. value 's ownership is transferred to pspec (which means pspec is then responsible for freeing it when no longer needed).

value must represent a data type, as understood by gda_g_type_from_string().

gda_sql_param_spec_take_descr ()

void
gda_sql_param_spec_take_descr (GdaSqlParamSpec *pspec,
                               GValue *value);

Sets pspec 's description. value 's ownership is transferred to pspec (which means pspec is then responsible for freeing it when no longer needed).

gda_sql_param_spec_take_nullok ()

void
gda_sql_param_spec_take_nullok (GdaSqlParamSpec *pspec,
                                GValue *value);

Sets pspec 's ability of being NULL. value 's ownership is transferred to pspec (which means pspec is then responsible for freeing it when no longer needed).

If value 's string starts by 't' or 'T' then pspec will be allowed to be NULL

gda_sql_param_spec_free ()

void
gda_sql_param_spec_free (GdaSqlParamSpec *pspec);

Destroys pspec .

gda_sql_param_spec_serialize ()

gchar *
gda_sql_param_spec_serialize (GdaSqlParamSpec *pspec);

Creates a new string representing pspec .

gda_sql_field_new ()

GdaSqlField *
gda_sql_field_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlField structure, using parent as its parent part.

gda_sql_field_free ()

void
gda_sql_field_free (GdaSqlField *field);

Frees a GdaSqlField structure and its members.

gda_sql_field_copy ()

GdaSqlField *
gda_sql_field_copy (GdaSqlField *field);

Creates a new GdaSqlField structure initiated with the values stored in field .

gda_sql_field_serialize ()

gchar *
gda_sql_field_serialize (GdaSqlField *field);

Creates a new string representing a field. You need to free the returned string using g_free();

gda_sql_field_take_name ()

void
gda_sql_field_take_name (GdaSqlField *field,
                         GValue *value);

Sets the field's name using the string held by value . When call, value is freed using gda_value_free().

gda_sql_table_new ()

GdaSqlTable *
gda_sql_table_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlTable structure, using parent as its parent part.

gda_sql_table_free ()

void
gda_sql_table_free (GdaSqlTable *table);

Frees a GdaSqlTable structure and its members.

gda_sql_table_copy ()

GdaSqlTable *
gda_sql_table_copy (GdaSqlTable *table);

Creates a new GdaSqlTable structure initiated with the values stored in table .

gda_sql_table_serialize ()

gchar *
gda_sql_table_serialize (GdaSqlTable *table);

Creates a new string representing a table. You need to free the returned string using g_free();

gda_sql_table_take_name ()

void
gda_sql_table_take_name (GdaSqlTable *table,
                         GValue *value);

Sets the table's name using the string held by value . When call, value is freed using gda_value_free().

gda_sql_function_new ()

GdaSqlFunction *
gda_sql_function_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlFunction structure initiated.

gda_sql_function_free ()

void
gda_sql_function_free (GdaSqlFunction *function);

Frees a GdaSqlFunction structure and its members.

gda_sql_function_copy ()

GdaSqlFunction *
gda_sql_function_copy (GdaSqlFunction *function);

Creates a new GdaSqlFunction structure initiated with the values stored in function .

gda_sql_function_serialize ()

gchar *
gda_sql_function_serialize (GdaSqlFunction *function);

Creates a new string representing a function. You need to free the returned string using g_free();

gda_sql_function_take_name ()

void
gda_sql_function_take_name (GdaSqlFunction *function,
                            GValue *value);

Sets the function's name using the string held by value . When call, value is freed using gda_value_free().

gda_sql_function_take_args_list ()

void
gda_sql_function_take_args_list (GdaSqlFunction *function,
                                 GSList *args);

Sets the function's arguments to point to args , then sets the list's data elements' parent to function .

gda_sql_operation_new ()

GdaSqlOperation *
gda_sql_operation_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlOperation structure and sets its parent to parent .

gda_sql_operation_free ()

void
gda_sql_operation_free (GdaSqlOperation *operation);

Frees a GdaSqlOperation structure and its members.

gda_sql_operation_copy ()

GdaSqlOperation *
gda_sql_operation_copy (GdaSqlOperation *operation);

Creates a new GdaSqlOperation structure initiated with the values stored in operation .

gda_sql_operation_serialize ()

gchar *
gda_sql_operation_serialize (GdaSqlOperation *operation);

Creates a new string representing an operator. You need to free the returned string using g_free();

gda_sql_operation_operator_to_string ()

const gchar *
gda_sql_operation_operator_to_string (GdaSqlOperatorType op);

Returns a constant string representing a operator name. You don't need to free the returned string.

gda_sql_operation_operator_from_string ()

GdaSqlOperatorType
gda_sql_operation_operator_from_string
                               (const gchar *op);

Returns GdaSqlOperatorType that correspond with the string op .

gda_sql_case_new ()

GdaSqlCase *
gda_sql_case_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlCase structure and sets its parent to parent .

gda_sql_case_free ()

void
gda_sql_case_free (GdaSqlCase *sc);

Frees a GdaSqlCase structure and its members.

gda_sql_case_copy ()

GdaSqlCase *
gda_sql_case_copy (GdaSqlCase *sc);

Creates a new GdaSqlCase structure initiated with the values stored in sc .

gda_sql_case_serialize ()

gchar *
gda_sql_case_serialize (GdaSqlCase *sc);

Creates a new string representing a CASE clause. You need to free the returned string using g_free();

gda_sql_select_field_new ()

GdaSqlSelectField *
gda_sql_select_field_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlSelectField structure and sets its parent to parent . A GdaSqlSelectField is any expression in SELECT statements before the FROM clause.

gda_sql_select_field_free ()

void
gda_sql_select_field_free (GdaSqlSelectField *field);

Frees a GdaSqlSelectField structure and its members.

gda_sql_select_field_copy ()

GdaSqlSelectField *
gda_sql_select_field_copy (GdaSqlSelectField *field);

Creates a new GdaSqlSelectField structure initiated with the values stored in field .

gda_sql_select_field_serialize ()

gchar *
gda_sql_select_field_serialize (GdaSqlSelectField *field);

Creates a new string representing an expression used as field in a SELECT statement before the FROM clause.

gda_sql_select_field_take_star_value ()

void
gda_sql_select_field_take_star_value (GdaSqlSelectField *field,
                                      GValue *value);

Sets the expression field's value in the GdaSqlSelectField structure to point to value ; after this field is the owner of value .

gda_sql_select_field_take_expr ()

void
gda_sql_select_field_take_expr (GdaSqlSelectField *field,
                                GdaSqlExpr *expr);

Sets the expression field in the GdaSqlSelectField structure to point to expr and modify it to sets its parent to field .

gda_sql_select_field_take_alias ()

void
gda_sql_select_field_take_alias (GdaSqlSelectField *field,
                                 GValue *alias);

Sets the 'as' field's string in the GdaSqlSelectField structure. alias is freed after call this function.

gda_sql_select_target_new ()

GdaSqlSelectTarget *
gda_sql_select_target_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlSelectTarget structure and sets its parent to parent . A GdaSqlSelectTarget is the table in a SELECT statement.

gda_sql_select_target_free ()

void
gda_sql_select_target_free (GdaSqlSelectTarget *target);

Frees a GdaSqlSelectTarget structure and its members.

gda_sql_select_target_copy ()

GdaSqlSelectTarget *
gda_sql_select_target_copy (GdaSqlSelectTarget *target);

Creates a new GdaSqlSelectTarget structure initiated with the values stored in target .

gda_sql_select_target_serialize ()

gchar *
gda_sql_select_target_serialize (GdaSqlSelectTarget *target);

Creates a new string representing a target used in a SELECT statement after the FROM clause.

gda_sql_select_target_take_table_name ()

void
gda_sql_select_target_take_table_name (GdaSqlSelectTarget *target,
                                       GValue *value);

Sets the target to be a SELECT subquery setting target's expression to use stmt ; after call this function the target owns stmt , then you must not free it.

gda_sql_select_target_take_select ()

void
gda_sql_select_target_take_select (GdaSqlSelectTarget *target,
                                   GdaSqlStatement *stmt);

gda_sql_select_target_take_alias ()

void
gda_sql_select_target_take_alias (GdaSqlSelectTarget *target,
                                  GValue *alias);

gda_sql_select_join_new ()

GdaSqlSelectJoin *
gda_sql_select_join_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlSelectJoin structure and sets its parent to parent .

gda_sql_select_join_free ()

void
gda_sql_select_join_free (GdaSqlSelectJoin *join);

Frees a GdaSqlSelectJoin structure and its members.

gda_sql_select_join_copy ()

GdaSqlSelectJoin *
gda_sql_select_join_copy (GdaSqlSelectJoin *join);

Creates a new GdaSqlSelectJoin structure initiated with the values stored in join .

gda_sql_select_join_serialize ()

gchar *
gda_sql_select_join_serialize (GdaSqlSelectJoin *join);

Creates a new string description of the join used in a SELECT statement.

gda_sql_select_join_type_to_string ()

const gchar *
gda_sql_select_join_type_to_string (GdaSqlSelectJoinType type);

Creates a new string representing the join type.

gda_sql_select_from_new ()

GdaSqlSelectFrom *
gda_sql_select_from_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlSelectFrom structure and sets its parent to parent .

gda_sql_select_from_free ()

void
gda_sql_select_from_free (GdaSqlSelectFrom *from);

Frees a GdaSqlSelectFrom structure and its members.

gda_sql_select_from_copy ()

GdaSqlSelectFrom *
gda_sql_select_from_copy (GdaSqlSelectFrom *from);

Creates a new GdaSqlSelectFrom structure initiated with the values stored in from .

gda_sql_select_from_serialize ()

gchar *
gda_sql_select_from_serialize (GdaSqlSelectFrom *from);

Creates a new string description of the FROM clause used in a SELECT statement.

gda_sql_select_from_take_new_target ()

void
gda_sql_select_from_take_new_target (GdaSqlSelectFrom *from,
                                     GdaSqlSelectTarget *target);

Append target to the targets in the FROM clause and set target 's parent to from ; after call this function from owns target then you must not free it.

gda_sql_select_from_take_new_join ()

void
gda_sql_select_from_take_new_join (GdaSqlSelectFrom *from,
                                   GdaSqlSelectJoin *join);

Append join to the joins in the FROM clause and set join 's parent to from ; after call this function from owns join then you must not free it.

gda_sql_select_order_new ()

GdaSqlSelectOrder *
gda_sql_select_order_new (GdaSqlAnyPart *parent);

Creates a new GdaSqlSelectOrder structure and sets its parent to parent .

gda_sql_select_order_free ()

void
gda_sql_select_order_free (GdaSqlSelectOrder *order);

Frees a GdaSqlSelectOrder structure and its members.

gda_sql_select_order_copy ()

GdaSqlSelectOrder *
gda_sql_select_order_copy (GdaSqlSelectOrder *order);

Creates a new GdaSqlSelectOrder structure initiated with the values stored in order .

gda_sql_select_order_serialize ()

gchar *
gda_sql_select_order_serialize (GdaSqlSelectOrder *order);

Creates a new string description of the ORDER BY clause used in a SELECT statement.

gda_sql_value_stringify ()

gchar *
gda_sql_value_stringify (const GValue *value);

Simplified version of gda_value_stringify().

GdaSqlStatement

typedef struct {
	gchar               *sql;
	GdaSqlStatementType  stmt_type;
	gpointer             contents; /* depends on stmt_type */
	GdaMetaStruct       *validity_meta_struct; /* set when gda_sql_statement_check_validity() was last called */
} GdaSqlStatement;

This structure is the top level structure encapsulating several type of statements.

enum GdaSqlStatementType

Known types of statements

struct GdaSqlAnyPart

struct GdaSqlAnyPart {
	GdaSqlAnyPartType  type;
	GdaSqlAnyPart     *parent;
};

Base structure of which all structures (except GdaSqlStatement) "inherit". It identifies, for each structure, its type and its parent in the structure hierarchy.

enum GdaSqlAnyPartType

Type of part.

GdaSqlStatementUnknown

typedef struct {
	GdaSqlAnyPart  any;
	GSList        *expressions;
} GdaSqlStatementUnknown;

Represents any statement which type is not identified (any DDL statement or database specific dialect)

GdaSqlStatementTransaction

typedef struct {
	GdaSqlAnyPart           any;
	GdaTransactionIsolation isolation_level;
	gchar                  *trans_mode; /* DEFERRED, IMMEDIATE, EXCLUSIVE, READ_WRITE, READ_ONLY */
	gchar                  *trans_name;
} GdaSqlStatementTransaction;

The statement is a transaction management related statement (BEGIN, ROLLBACK, etc). The GdaSqlStatementTransaction structure does not hold enough information to reconstruct the complete SQL statement (some information may be missing) - the aim of this structure is to identify a minimum set of information in the transaction statement. Note that the complete SQL which created the statement should be available in the GdaSqlStatement structure which encapsulates this structure.

GdaSqlStatementSelect

typedef struct {
	GdaSqlAnyPart     any;
	gboolean          distinct;
	GdaSqlExpr       *distinct_expr;

	GSList           *expr_list;  /* list of GdaSqlSelectField pointers */
	GdaSqlSelectFrom *from;

	GdaSqlExpr       *where_cond; /* WHERE... */
	GSList           *group_by; /* list of GdaSqlExpr pointers */
	GdaSqlExpr       *having_cond; /* HAVING... */
	GSList           *order_by;   /* list of GdaSqlSelectOrder pointers */

	GdaSqlExpr       *limit_count;
	GdaSqlExpr       *limit_offset;
} GdaSqlStatementSelect;

GdaSqlStatementInsert

typedef struct {
	GdaSqlAnyPart           any;
	gchar                  *on_conflict; /* conflict resolution clause */
	GdaSqlTable            *table;
	GSList                 *fields_list; /* list of GdaSqlField structures */
	GSList                 *values_list; /* list of list of GdaSqlExpr */
	GdaSqlAnyPart          *select; /* SELECT OR COMPOUND statements: GdaSqlStatementSelect or GdaSqlStatementCompound */
} GdaSqlStatementInsert;

The statement is an INSERT statement, any kind of INSERT statement can be represented using this structure (if this is not the case then report a bug).

Example of a GdaSqlStatement having a GdaSqlStatementInsert as its contents with 2 lists of values to insert.

Another example of a GdaSqlStatement having a GdaSqlStatementInsert as its contents, using a SELECT to express the values to insert.

GdaSqlStatementDelete

typedef struct {
	GdaSqlAnyPart any;
	GdaSqlTable  *table;
	GdaSqlExpr   *cond;
} GdaSqlStatementDelete;

GdaSqlStatementUpdate

typedef struct {
	GdaSqlAnyPart     any;
	gchar            *on_conflict; /* conflict resolution clause */
	GdaSqlTable      *table;
	GSList           *fields_list; /* list of GdaSqlField pointers */
	GSList           *expr_list;   /* list of GdaSqlExpr pointers */
	GdaSqlExpr       *cond;
} GdaSqlStatementUpdate;

GdaSqlStatementCompound

typedef struct {
	GdaSqlAnyPart                any;
	GdaSqlStatementCompoundType  compound_type;
	GSList                      *stmt_list; /* list of SELECT or COMPOUND statements */
} GdaSqlStatementCompound;

enum GdaSqlStatementCompoundType

struct GdaSqlExpr

struct GdaSqlExpr {
	GdaSqlAnyPart    any;
	GValue          *value;
	GdaSqlParamSpec *param_spec;
	GdaSqlFunction  *func;
	GdaSqlOperation *cond;
	GdaSqlAnyPart   *select; /* SELECT OR COMPOUND statements: GdaSqlStatementSelect or GdaSqlStatementCompound */
	GdaSqlCase      *case_s;

	gchar           *cast_as;

	gboolean         value_is_ident;
};

This structure contains any expression, either as a value (the value part is set), a variable (the param_spec is set), or as other types of expressions.

Note 1 about the value field: if the expression represents a string value in the SQL statement, the string itself must be represented as it would be in the actual SQL, ie. it should be escaped (accordingly to the escaping rules of the database which will use the SQL). For example a string representing the 'joe' value should be

Note 2 about the value field: if the expression represents an SQL identifier (such as a table or field name), then the value_is_ident should be set to TRUE, and value should be a string which may contain double quotes around SQL identifiers which also are reserved keywords or which are case sensitive.

struct GdaSqlParamSpec

struct GdaSqlParamSpec {
	gchar    *name;
	gchar    *descr;
	gboolean  is_param;
	gboolean  nullok;

	GType     g_type;
	gpointer  validity_meta_dict; /* to be replaced with a pointer to a structure representing a DBMS data type in GdaMetaStruct */

	/* Padding for future expansion */
	gpointer         _gda_reserved1;
	gpointer         _gda_reserved2;
};

struct GdaSqlField

struct GdaSqlField {
	GdaSqlAnyPart       any;
	gchar              *field_name;

	/* validity check with a connection */
	GdaMetaTableColumn *validity_meta_table_column;
};

This structure represents the name of a table's field.

struct GdaSqlTable

struct GdaSqlTable {
	GdaSqlAnyPart       any;
	gchar              *table_name;

	/* validity check with a connection */
	GdaMetaDbObject    *validity_meta_object;
};

This structure represents the name of a table.

struct GdaSqlFunction

struct GdaSqlFunction {
	GdaSqlAnyPart       any;
	gchar              *function_name;
	GSList             *args_list;
};

This structure represents a function or an aggregate with zero or more arguments.

struct GdaSqlOperation

struct GdaSqlOperation {
	GdaSqlAnyPart       any;
	GdaSqlOperatorType  operator_type;
	GSList             *operands;
};

This structure represents an operation between one or more operands.

enum GdaSqlOperatorType

struct GdaSqlCase

struct GdaSqlCase {
	GdaSqlAnyPart    any;
	GdaSqlExpr      *base_expr;
	GSList          *when_expr_list;
	GSList          *then_expr_list;
	GdaSqlExpr      *else_expr;
};

This structure represents a CASE WHEN... construct

struct GdaSqlSelectField

struct GdaSqlSelectField {
	GdaSqlAnyPart       any;
	GdaSqlExpr         *expr;
	gchar              *field_name; /* may be NULL if expr does not refer to a table.field, can also be "*" */
	gchar              *table_name; /* may be NULL if expr does not refer to a table.field */
	gchar              *as;

	/* validity check with a connection */
	GdaMetaDbObject    *validity_meta_object;
	GdaMetaTableColumn *validity_meta_table_column;
};

This structure represents a selected item in a SELECT statement (when executed, the returned data set will have one column per selected item). Note that the table_name and field_name field parts will be overwritten by Libgda, set the value of expr->value instead.

struct GdaSqlSelectTarget

struct GdaSqlSelectTarget {
	GdaSqlAnyPart       any;
	GdaSqlExpr         *expr;
	gchar              *table_name; /* may be NULL if expr does not refer to a table */
	gchar              *as;

	/* validity check with a connection */
	GdaMetaDbObject    *validity_meta_object;
};

This structure represents a target used to fetch data from in a SELECT statement; it can represent a table or a sub select. Note that the table_name part will be overwritten by Libgda, set the value of expr->value instead.

struct GdaSqlSelectJoin

struct GdaSqlSelectJoin {
	GdaSqlAnyPart         any;
	GdaSqlSelectJoinType  type;
	gint                  position; /* between a target at (pos < @position) and the one @position */
	GdaSqlExpr           *expr;
	GSList               *use; /* list of GdaSqlField pointers */
};

This structure represents a join between two targets in a SELECT statement.

enum GdaSqlSelectJoinType

struct GdaSqlSelectFrom

struct GdaSqlSelectFrom {
	GdaSqlAnyPart    any;
	GSList          *targets;
	GSList          *joins;
};

This structure represents the FROM clause of a SELECT statement, it lists targets and joins

struct GdaSqlSelectOrder

struct GdaSqlSelectOrder {
	GdaSqlAnyPart    any;
	GdaSqlExpr      *expr;
	gboolean         asc;
	gchar           *collation_name;
};

This structure represents the ordering of a SELECT statement.