![]() |
![]() |
![]() |
GNOME Data Access 4.0 manual | ![]() |
---|---|---|---|---|
GdaSqlStatement; enum GdaSqlStatementType; GdaSqlStatement* gda_sql_statement_new (GdaSqlStatementType type); GdaSqlStatement* gda_sql_statement_copy (GdaSqlStatement *stmt); void gda_sql_statement_free (GdaSqlStatement *stmt); gchar* gda_sql_statement_serialize (GdaSqlStatement *stmt); const gchar* gda_sql_statement_type_to_string (GdaSqlStatementType type); GdaSqlStatementType gda_sql_statement_string_to_type (const gchar *type); gboolean gda_sql_statement_check_structure (GdaSqlStatement *stmt, GError **error); gboolean gda_sql_statement_check_connection (GdaSqlStatement *stmt, GdaConnection *cnc, GError **error); void gda_sql_statement_check_clean (GdaSqlStatement *stmt); GdaSqlAnyPart; enum GdaSqlAnyPartType; #define GDA_SQL_ANY_PART (x) gboolean (*GdaSqlForeachFunc) (GdaSqlAnyPart *, gpointer , GError **); gboolean gda_sql_any_part_foreach (GdaSqlAnyPart *node, GdaSqlForeachFunc func, gpointer data, GError **error); GdaSqlStatementUnknown; void gda_sql_statement_unknown_take_expressions (GdaSqlStatement *stmt, GSList *expressions); GdaSqlStatementTransaction; void gda_sql_statement_trans_take_mode (GdaSqlStatement *stmt, GValue *value); void gda_sql_statement_trans_take_name (GdaSqlStatement *stmt, GValue *value); void gda_sql_statement_trans_set_isol_level (GdaSqlStatement *stmt, GdaTransactionIsolation level); GdaSqlStatementSelect; void gda_sql_statement_select_take_distinct (GdaSqlStatement *stmt, gboolean distinct, GdaSqlExpr *distinct_expr); void gda_sql_statement_select_take_expr_list (GdaSqlStatement *stmt, GSList *expr_list); void gda_sql_statement_select_take_from (GdaSqlStatement *stmt, GdaSqlSelectFrom *from); void gda_sql_statement_select_take_where_cond (GdaSqlStatement *stmt, GdaSqlExpr *expr); void gda_sql_statement_select_take_group_by (GdaSqlStatement *stmt, GSList *group_by); void gda_sql_statement_select_take_having_cond (GdaSqlStatement *stmt, GdaSqlExpr *expr); void gda_sql_statement_select_take_order_by (GdaSqlStatement *stmt, GSList *order_by); void gda_sql_statement_select_take_limits (GdaSqlStatement *stmt, GdaSqlExpr *count, GdaSqlExpr *offset); GdaSqlStatementInsert; void gda_sql_statement_insert_take_table_name (GdaSqlStatement *stmt, GValue *value); void gda_sql_statement_insert_take_on_conflict (GdaSqlStatement *stmt, GValue *value); void gda_sql_statement_insert_take_fields_list (GdaSqlStatement *stmt, GSList *list); void gda_sql_statement_insert_take_1_values_list (GdaSqlStatement *stmt, GSList *list); void gda_sql_statement_insert_take_extra_values_list (GdaSqlStatement *stmt, GSList *list); void gda_sql_statement_insert_take_select (GdaSqlStatement *stmt, GdaSqlStatement *select); GdaSqlStatementDelete; void gda_sql_statement_delete_take_table_name (GdaSqlStatement *stmt, GValue *value); void gda_sql_statement_delete_take_condition (GdaSqlStatement *stmt, GdaSqlExpr *cond); GdaSqlStatementUpdate; void gda_sql_statement_update_take_table_name (GdaSqlStatement *stmt, GValue *value); void gda_sql_statement_update_take_on_conflict (GdaSqlStatement *stmt, GValue *value); void gda_sql_statement_update_take_condition (GdaSqlStatement *stmt, GdaSqlExpr *cond); void gda_sql_statement_update_take_set_value (GdaSqlStatement *stmt, GValue *fname, GdaSqlExpr *expr); GdaSqlStatementCompound; void gda_sql_statement_compound_set_type (GdaSqlStatement *stmt, GdaSqlStatementCompoundType type); void gda_sql_statement_compound_take_stmt (GdaSqlStatement *stmt, GdaSqlStatement *s); GdaSqlAnyPart* gda_sql_statement_compound_reduce (GdaSqlAnyPart *compound_or_select); GdaSqlExpr; GdaSqlExpr* gda_sql_expr_new (GdaSqlAnyPart *parent); void gda_sql_expr_free (GdaSqlExpr *expr); GdaSqlExpr* gda_sql_expr_copy (GdaSqlExpr *expr); gchar* gda_sql_expr_serialize (GdaSqlExpr *expr); void gda_sql_expr_take_select (GdaSqlExpr *expr, GdaSqlStatement *stmt); GdaSqlParamSpec; GdaSqlParamSpec* gda_sql_param_spec_new (GValue *simple_spec); GdaSqlParamSpec* gda_sql_param_spec_copy (GdaSqlParamSpec *pspec); void gda_sql_param_spec_take_name (GdaSqlParamSpec *pspec, GValue *value); void gda_sql_param_spec_take_type (GdaSqlParamSpec *pspec, GValue *value); void gda_sql_param_spec_take_descr (GdaSqlParamSpec *pspec, GValue *value); void gda_sql_param_spec_take_nullok (GdaSqlParamSpec *pspec, GValue *value); void gda_sql_param_spec_free (GdaSqlParamSpec *pspec); gchar* gda_sql_param_spec_serialize (GdaSqlParamSpec *pspec); GdaSqlField; GdaSqlField* gda_sql_field_new (GdaSqlAnyPart *parent); void gda_sql_field_free (GdaSqlField *field); GdaSqlField* gda_sql_field_copy (GdaSqlField *field); gchar* gda_sql_field_serialize (GdaSqlField *field); void gda_sql_field_take_name (GdaSqlField *field, GValue *value); GdaSqlTable; GdaSqlTable* gda_sql_table_new (GdaSqlAnyPart *parent); void gda_sql_table_free (GdaSqlTable *table); GdaSqlTable* gda_sql_table_copy (GdaSqlTable *table); gchar* gda_sql_table_serialize (GdaSqlTable *table); void gda_sql_table_take_name (GdaSqlTable *table, GValue *value); GdaSqlFunction; GdaSqlFunction* gda_sql_function_new (GdaSqlAnyPart *parent); void gda_sql_function_free (GdaSqlFunction *function); GdaSqlFunction* gda_sql_function_copy (GdaSqlFunction *function); gchar* gda_sql_function_serialize (GdaSqlFunction *function); void gda_sql_function_take_name (GdaSqlFunction *function, GValue *value); void gda_sql_function_take_args_list (GdaSqlFunction *function, GSList *args); GdaSqlOperation; enum GdaSqlOperator; GdaSqlOperation* gda_sql_operation_new (GdaSqlAnyPart *parent); void gda_sql_operation_free (GdaSqlOperation *operation); GdaSqlOperation* gda_sql_operation_copy (GdaSqlOperation *operation); gchar* gda_sql_operation_serialize (GdaSqlOperation *operation); const gchar* gda_sql_operation_operator_to_string (GdaSqlOperator op); GdaSqlOperator gda_sql_operation_operator_from_string (const gchar *op); GdaSqlCase; GdaSqlCase* gda_sql_case_new (GdaSqlAnyPart *parent); void gda_sql_case_free (GdaSqlCase *scase); GdaSqlCase* gda_sql_case_copy (GdaSqlCase *scase); gchar* gda_sql_case_serialize (GdaSqlCase *scase); GdaSqlSelectField; GdaSqlSelectField* gda_sql_select_field_new (GdaSqlAnyPart *parent); void gda_sql_select_field_free (GdaSqlSelectField *field); GdaSqlSelectField* gda_sql_select_field_copy (GdaSqlSelectField *field); gchar* gda_sql_select_field_serialize (GdaSqlSelectField *field); void gda_sql_select_field_take_star_value (GdaSqlSelectField *field, GValue *value); void gda_sql_select_field_take_expr (GdaSqlSelectField *field, GdaSqlExpr *expr); void gda_sql_select_field_take_alias (GdaSqlSelectField *field, GValue *alias); GdaSqlSelectTarget; GdaSqlSelectTarget* gda_sql_select_target_new (GdaSqlAnyPart *parent); void gda_sql_select_target_free (GdaSqlSelectTarget *target); GdaSqlSelectTarget* gda_sql_select_target_copy (GdaSqlSelectTarget *target); gchar* gda_sql_select_target_serialize (GdaSqlSelectTarget *target); void gda_sql_select_target_take_table_name (GdaSqlSelectTarget *target, GValue *value); void gda_sql_select_target_take_select (GdaSqlSelectTarget *target, GdaSqlStatement *stmt); void gda_sql_select_target_take_alias (GdaSqlSelectTarget *target, GValue *alias); GdaSqlSelectJoin; GdaSqlSelectJoin* gda_sql_select_join_new (GdaSqlAnyPart *parent); void gda_sql_select_join_free (GdaSqlSelectJoin *join); GdaSqlSelectJoin* gda_sql_select_join_copy (GdaSqlSelectJoin *join); gchar* gda_sql_select_join_serialize (GdaSqlSelectJoin *join); const gchar* gda_sql_select_join_type_to_string (GdaSqlSelectJoinType type); GdaSqlSelectFrom; GdaSqlSelectFrom* gda_sql_select_from_new (GdaSqlAnyPart *parent); void gda_sql_select_from_free (GdaSqlSelectFrom *from); GdaSqlSelectFrom* gda_sql_select_from_copy (GdaSqlSelectFrom *from); gchar* gda_sql_select_from_serialize (GdaSqlSelectFrom *from); void gda_sql_select_from_take_new_target (GdaSqlSelectFrom *from, GdaSqlSelectTarget *target); void gda_sql_select_from_take_new_join (GdaSqlSelectFrom *from, GdaSqlSelectJoin *join); GdaSqlSelectOrder; GdaSqlSelectOrder* gda_sql_select_order_new (GdaSqlAnyPart *parent); void gda_sql_select_order_free (GdaSqlSelectOrder *order); GdaSqlSelectOrder* gda_sql_select_order_copy (GdaSqlSelectOrder *order); gchar* gda_sql_select_order_serialize (GdaSqlSelectOrder *order);
Every SQL statement can be decomposed in a GdaSqlStatement structure. This is not a GObject, but rather just a C structure which can be manipulated directly. The structure is a tree composed of several key structures which are show in the following diagram (even though it does not show, all structures "inherit" the GdaSqlAnyPart structure which holds some basic information).
Main parts of the GdaSqlStatement structure.
The samples/SqlParserConsole directory of libgda's sources contains a small utility to display statements' structures as a graph (using the GraphViz language). It has been used to provide the examples in this section of the documentation.
typedef struct { gchar *sql; GdaSqlStatementType stmt_type; gpointer contents; /* depends on stmt_type */ } GdaSqlStatement;
Container structure for an SQL statement.
gchar *sql ; |
the actual SQL string which corresponds to the statement, or NULL
|
GdaSqlStatementType stmt_type ; |
the type of statement (SELECT, INSERT, etc) as a GdaSqlStatementType enum |
gpointer contents ; |
the actual contents of the statement, depends on stmt_type (can be a pointer to a
GdaSqlStatementSelect, GdaSqlStatementInsert, etc)
|
typedef enum { GDA_SQL_STATEMENT_SELECT, GDA_SQL_STATEMENT_INSERT, GDA_SQL_STATEMENT_UPDATE, GDA_SQL_STATEMENT_DELETE, GDA_SQL_STATEMENT_COMPOUND, GDA_SQL_STATEMENT_BEGIN, GDA_SQL_STATEMENT_ROLLBACK, GDA_SQL_STATEMENT_COMMIT, GDA_SQL_STATEMENT_SAVEPOINT, GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT, GDA_SQL_STATEMENT_DELETE_SAVEPOINT, GDA_SQL_STATEMENT_UNKNOWN, GDA_SQL_STATEMENT_NONE } GdaSqlStatementType;
Known types of statements
GdaSqlStatement* gda_sql_statement_new (GdaSqlStatementType type);
type : |
|
Returns : |
GdaSqlStatement* gda_sql_statement_copy (GdaSqlStatement *stmt);
stmt : |
|
Returns : |
gchar* gda_sql_statement_serialize (GdaSqlStatement *stmt);
stmt : |
|
Returns : |
const gchar* gda_sql_statement_type_to_string (GdaSqlStatementType type);
type : |
|
Returns : |
GdaSqlStatementType gda_sql_statement_string_to_type (const gchar *type);
type : |
|
Returns : |
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 targetted).
stmt : |
a GdaSqlStatement pointer |
error : |
a place to store errors, or NULL
|
Returns : | TRUE if no error occurred |
gboolean gda_sql_statement_check_connection (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).
If cnc
is NULL
, then remove any information from a previous call to this method stored in stmt
.
stmt : |
a GdaSqlStatement pointer |
cnc : |
a GdaConnection object, or NULL
|
error : |
a place to store errors, or NULL
|
Returns : | TRUE if no error occurred |
typedef struct { GdaSqlAnyPartType type; GdaSqlAnyPart *parent; } GdaSqlAnyPart;
Base structure of which all structures (except GdaSqlStatement) "inherit". It identifies, for each structure, its type and its parent in the structure hierarchy.
GdaSqlAnyPartType type ; |
type of structure, as a GdaSqlAnyPartType enum. |
GdaSqlAnyPart *parent ; |
pointer to the parent GdaSqlAnyPart structure |
typedef enum { /* complete statements */ GDA_SQL_ANY_STMT_SELECT = GDA_SQL_STATEMENT_SELECT, GDA_SQL_ANY_STMT_INSERT = GDA_SQL_STATEMENT_INSERT, GDA_SQL_ANY_STMT_UPDATE = GDA_SQL_STATEMENT_UPDATE, GDA_SQL_ANY_STMT_DELETE = GDA_SQL_STATEMENT_DELETE, GDA_SQL_ANY_STMT_COMPOUND = GDA_SQL_STATEMENT_COMPOUND, GDA_SQL_ANY_STMT_BEGIN = GDA_SQL_STATEMENT_BEGIN, GDA_SQL_ANY_STMT_ROLLBACK = GDA_SQL_STATEMENT_ROLLBACK, GDA_SQL_ANY_STMT_COMMIT = GDA_SQL_STATEMENT_COMMIT, GDA_SQL_ANY_STMT_SAVEPOINT = GDA_SQL_STATEMENT_SAVEPOINT, GDA_SQL_ANY_STMT_ROLLBACK_SAVEPOINT = GDA_SQL_STATEMENT_ROLLBACK_SAVEPOINT, GDA_SQL_ANY_STMT_DELETE_SAVEPOINT = GDA_SQL_STATEMENT_DELETE_SAVEPOINT, GDA_SQL_ANY_STMT_UNKNOWN = GDA_SQL_STATEMENT_UNKNOWN, /* individual parts */ GDA_SQL_ANY_EXPR = 500, GDA_SQL_ANY_SQL_FIELD, GDA_SQL_ANY_SQL_TABLE, GDA_SQL_ANY_SQL_FUNCTION, GDA_SQL_ANY_SQL_OPERATION, GDA_SQL_ANY_SQL_CASE, GDA_SQL_ANY_SQL_SELECT_FIELD, GDA_SQL_ANY_SQL_SELECT_TARGET, GDA_SQL_ANY_SQL_SELECT_JOIN, GDA_SQL_ANY_SQL_SELECT_FROM, GDA_SQL_ANY_SQL_SELECT_ORDER } GdaSqlAnyPartType;
GDA_SQL_ANY_STMT_SELECT |
structure is a GdaSqlStatementSelect |
GDA_SQL_ANY_STMT_INSERT |
structure is a GdaSqlStatementInsert |
GDA_SQL_ANY_STMT_UPDATE |
structure is a GdaSqlStatementUpdate |
GDA_SQL_ANY_STMT_DELETE |
structure is a GdaSqlStatementDelete |
GDA_SQL_ANY_STMT_COMPOUND |
structure is a GdaSqlStatementCompound |
GDA_SQL_ANY_STMT_BEGIN |
structure is a GdaSqlStatementTransaction |
GDA_SQL_ANY_STMT_ROLLBACK |
structure is a GdaSqlStatementTransaction |
GDA_SQL_ANY_STMT_COMMIT |
structure is a GdaSqlStatementTransaction |
GDA_SQL_ANY_STMT_SAVEPOINT |
structure is a GdaSqlStatementTransaction |
GDA_SQL_ANY_STMT_ROLLBACK_SAVEPOINT |
structure is a GdaSqlStatementTransaction |
GDA_SQL_ANY_STMT_DELETE_SAVEPOINT |
structure is a GdaSqlStatementTransaction |
GDA_SQL_ANY_STMT_UNKNOWN |
structure is a GdaSqlStatementUnknown |
GDA_SQL_ANY_EXPR |
structure is a GdaSqlExpr |
GDA_SQL_ANY_SQL_FIELD |
structure is a GdaSqlField |
GDA_SQL_ANY_SQL_TABLE |
structure is a GdaSqlTable |
GDA_SQL_ANY_SQL_FUNCTION |
structure is a GdaSqlFunction |
GDA_SQL_ANY_SQL_OPERATION |
structure is a GdaSqlOperation |
GDA_SQL_ANY_SQL_CASE |
structure is a GdaSqlCase |
GDA_SQL_ANY_SQL_SELECT_FIELD |
structure is a GdaSqlSelectField |
GDA_SQL_ANY_SQL_SELECT_TARGET |
structure is a GdaSqlSelectTarget |
GDA_SQL_ANY_SQL_SELECT_JOIN |
structure is a GdaSqlSelectJoin |
GDA_SQL_ANY_SQL_SELECT_FROM |
structure is a GdaSqlSelectFrom |
GDA_SQL_ANY_SQL_SELECT_ORDER |
structure is a GdaSqlSelectOrder |
gboolean (*GdaSqlForeachFunc) (GdaSqlAnyPart *, gpointer , GError **);
Specifies the type of functions passed to gda_sql_any_part_foreach()
.
Param1 : |
the current GdaSqlAnyPart node |
Param2 : |
user data passed to gda_sql_any_part_foreach() .
|
Param3 : |
pointer to a place to store errors |
Returns : | FALSE if the gda_sql_any_part_foreach() should stop at this point and fail
|
gboolean gda_sql_any_part_foreach (GdaSqlAnyPart *node, GdaSqlForeachFunc func, gpointer data, GError **error);
Calls a function for each element of a GdaSqlAnyPart node
node : |
the stat node |
func : |
function to call for each sub node |
data : |
data to pass to func each time it is called
|
error : |
a place to store errors, or NULL (is also passed to func )
|
Returns : | TRUE if func has been called for any sub node of node and always returned TRUE, or FALSE
otherwise.
|
typedef struct { GdaSqlAnyPart any; GSList *expressions; /* list of GdaSqlExpr pointers */ } GdaSqlStatementUnknown;
The SQL statement is of an unknown type (not any of the other parsed types). Such structure is created by the GdaSqlParser object when it cannot parse the SQL string, or when operating in delimiter mode (it only tries to delimit statements if there are several ones in the same SQL string).
Example of a GdaSqlStatement having a GdaSqlStatementUnknown as its contents (the parsed string is "a string;" which is not a valid SQL statement). The arrows are named after the attribute they represent (here the "expressions" attribute). Lists are represented by the GSList nodes and a "data" pointer which points to the data, and a "next" pointer which points to the next node in the list, all of the graphical items are in gray.
GdaSqlAnyPart any ; |
inheritance structure |
GSList *expressions ; |
a GSList of GdaSqlExpr expressions |
void gda_sql_statement_unknown_take_expressions (GdaSqlStatement *stmt, GSList *expressions);
stmt : |
|
expressions : |
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.
GdaSqlAnyPart any ; |
inheritance structure |
GdaTransactionIsolation isolation_level ; |
isolation level as a GdaTransactionIsolation |
gchar *trans_mode ; |
transaction mode (DEFERRED, IMMEDIATE, EXCLUSIVE, READ_WRITE, READ_ONLY) |
gchar *trans_name ; |
transaction name |
void gda_sql_statement_trans_take_mode (GdaSqlStatement *stmt, GValue *value);
stmt : |
|
value : |
void gda_sql_statement_trans_take_name (GdaSqlStatement *stmt, GValue *value);
stmt : |
|
value : |
void gda_sql_statement_trans_set_isol_level (GdaSqlStatement *stmt, GdaTransactionIsolation level);
stmt : |
|
level : |
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;
The statement is a SELECT statement, any kind of SELECT statement can be represented using this structure (if this is not the case then report a bug).
Example of a GdaSqlStatement having a GdaSqlStatementSelect as its contents.
GdaSqlAnyPart any ; |
inheritance structure |
gboolean distinct ; |
TRUE if a DISTINCT clause applies |
GdaSqlExpr *distinct_expr ; |
expression on which the distinct applies, or NULL
|
GSList *expr_list ; |
list of expressions, one for each column in the data set returned by the execution of the statement |
GdaSqlSelectFrom *from ; |
target(s) of the SELECT statement |
GdaSqlExpr *where_cond ; |
condition expression filtering the resulting data set (WHERE condition) |
GSList *group_by ; |
grouping expressions |
GdaSqlExpr *having_cond ; |
condition expression filtering the groupped expressions (HAVING condition) |
GSList *order_by ; |
ordering expressions |
GdaSqlExpr *limit_count ; |
size limiting expression (LIMIT clause) |
GdaSqlExpr *limit_offset ; |
when limit_count is defined, the start offset for the limit
|
void gda_sql_statement_select_take_distinct (GdaSqlStatement *stmt, gboolean distinct, GdaSqlExpr *distinct_expr);
stmt : |
|
distinct : |
|
distinct_expr : |
void gda_sql_statement_select_take_expr_list (GdaSqlStatement *stmt, GSList *expr_list);
stmt : |
|
expr_list : |
void gda_sql_statement_select_take_from (GdaSqlStatement *stmt, GdaSqlSelectFrom *from);
stmt : |
|
from : |
void gda_sql_statement_select_take_where_cond (GdaSqlStatement *stmt, GdaSqlExpr *expr);
stmt : |
|
expr : |
void gda_sql_statement_select_take_group_by (GdaSqlStatement *stmt, GSList *group_by);
stmt : |
|
group_by : |
void gda_sql_statement_select_take_having_cond (GdaSqlStatement *stmt, GdaSqlExpr *expr);
stmt : |
|
expr : |
void gda_sql_statement_select_take_order_by (GdaSqlStatement *stmt, GSList *order_by);
stmt : |
|
order_by : |
void gda_sql_statement_select_take_limits (GdaSqlStatement *stmt, GdaSqlExpr *count, GdaSqlExpr *offset);
stmt : |
|
count : |
|
offset : |
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.
GdaSqlAnyPart any ; |
inheritance structure |
gchar *on_conflict ; |
conflict resolution clause if there is one (such as "OR REPLACE") |
GdaSqlTable *table ; |
name of the table to which data is inserted |
GSList *fields_list ; |
list of GdaSqlField fields which are valued for insertion |
GSList *values_list ; |
list of list of GdaSqlExpr expressions (this is a list of list, not a simple list) |
GdaSqlAnyPart *select ; |
a GdaSqlStatementSelect or GdaSqlStatementCompound structure representing the values to insert |
void gda_sql_statement_insert_take_table_name (GdaSqlStatement *stmt, GValue *value);
stmt : |
|
value : |
void gda_sql_statement_insert_take_on_conflict (GdaSqlStatement *stmt, GValue *value);
stmt : |
|
value : |
void gda_sql_statement_insert_take_fields_list (GdaSqlStatement *stmt, GSList *list);
stmt : |
|
list : |
void gda_sql_statement_insert_take_1_values_list (GdaSqlStatement *stmt, GSList *list);
stmt : |
|
list : |
void gda_sql_statement_insert_take_extra_values_list (GdaSqlStatement *stmt, GSList *list);
stmt : |
|
list : |
void gda_sql_statement_insert_take_select (GdaSqlStatement *stmt, GdaSqlStatement *select);
stmt : |
|
select : |
typedef struct { GdaSqlAnyPart any; GdaSqlTable *table; GdaSqlExpr *cond; } GdaSqlStatementDelete;
The statement is a DELETE statement, any kind of DELETE statement can be represented using this structure (if this is not the case then report a bug).
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlTable *table ; |
name of the table from which data is deleted |
GdaSqlExpr *cond ; |
WHERE clause for the DELETE |
void gda_sql_statement_delete_take_table_name (GdaSqlStatement *stmt, GValue *value);
stmt : |
|
value : |
void gda_sql_statement_delete_take_condition (GdaSqlStatement *stmt, GdaSqlExpr *cond);
stmt : |
|
cond : |
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;
The statement is an UPDATE statement, any kind of UPDATE statement can be represented using this structure (if this is not the case then report a bug).
Example of a GdaSqlStatement having a GdaSqlStatementUpdate as its contents.
GdaSqlAnyPart any ; |
inheritance structure |
gchar *on_conflict ; |
conflict resolution clause if there is one (such as "OR REPLACE") |
GdaSqlTable *table ; |
name of the table to which data is updated |
GSList *fields_list ; |
list of GdaSqlField fields which are updated |
GSList *expr_list ; |
list of GdaSqlExpr expressions containing the new values |
GdaSqlExpr *cond ; |
WHERE clause for the UPDATE |
void gda_sql_statement_update_take_table_name (GdaSqlStatement *stmt, GValue *value);
stmt : |
|
value : |
void gda_sql_statement_update_take_on_conflict (GdaSqlStatement *stmt, GValue *value);
stmt : |
|
value : |
void gda_sql_statement_update_take_condition (GdaSqlStatement *stmt, GdaSqlExpr *cond);
stmt : |
|
cond : |
void gda_sql_statement_update_take_set_value (GdaSqlStatement *stmt, GValue *fname, GdaSqlExpr *expr);
stmt : |
|
fname : |
|
expr : |
typedef struct { GdaSqlAnyPart any; GdaSqlStatementCompoundType compound_type; GSList *stmt_list; /* list of SELECT or COMPOUND statements */ } GdaSqlStatementCompound;
The statement is a compound selection statement: multiple SELECT or compound statements composed together with UNION, EXCEPT or INSERSECT operations. Any kind of compound statement can be represented using this structure (if this is not the case then report a bug).
Example of a GdaSqlStatement having a GdaSqlStatementCompound as its contents.
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlStatementCompoundType compound_type ; |
the type of operation to compose the selection or compound statements making this statement |
GSList *stmt_list ; |
a list of GdaSqlStatement making this statement |
void gda_sql_statement_compound_set_type (GdaSqlStatement *stmt, GdaSqlStatementCompoundType type);
stmt : |
|
type : |
void gda_sql_statement_compound_take_stmt (GdaSqlStatement *stmt, GdaSqlStatement *s);
stmt : |
|
s : |
GdaSqlAnyPart* gda_sql_statement_compound_reduce (GdaSqlAnyPart *compound_or_select);
compound_or_select : |
|
Returns : |
typedef struct { 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; } GdaSqlExpr;
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.
GdaSqlAnyPart any ; |
inheritance structure |
GValue *value ; |
a GValue, or NULL
|
GdaSqlParamSpec *param_spec ; |
a GdaSqlParamSpec, or NULL if this is not a variable
|
GdaSqlFunction *func ; |
not NULL if expression is a function or aggregate
|
GdaSqlOperation *cond ; |
not NULL if expression is a condition or an operation
|
GdaSqlAnyPart *select ; |
not NULL if expression is a sub select statement (GdaSqlStatementSelect or GdaSqlStatementCompound)
|
GdaSqlCase *case_s ; |
not NULL if expression is a CASE WHEN ... expression
|
gchar *cast_as ; |
not NULL if expression must be cast to another data type
|
void gda_sql_expr_take_select (GdaSqlExpr *expr, GdaSqlStatement *stmt);
expr : |
|
stmt : |
typedef struct { gchar *name; gchar *descr; gchar *type; gboolean is_param; gboolean nullok; GType g_type; gpointer dict_type; } GdaSqlParamSpec;
GdaSqlParamSpec* gda_sql_param_spec_new (GValue *simple_spec);
simple_spec : |
|
Returns : |
GdaSqlParamSpec* gda_sql_param_spec_copy (GdaSqlParamSpec *pspec);
pspec : |
|
Returns : |
void gda_sql_param_spec_take_name (GdaSqlParamSpec *pspec, GValue *value);
pspec : |
|
value : |
void gda_sql_param_spec_take_type (GdaSqlParamSpec *pspec, GValue *value);
pspec : |
|
value : |
void gda_sql_param_spec_take_descr (GdaSqlParamSpec *pspec, GValue *value);
pspec : |
|
value : |
void gda_sql_param_spec_take_nullok (GdaSqlParamSpec *pspec, GValue *value);
pspec : |
|
value : |
gchar* gda_sql_param_spec_serialize (GdaSqlParamSpec *pspec);
pspec : |
|
Returns : |
typedef struct { GdaSqlAnyPart any; gchar *field_name; } GdaSqlField;
This structure represents the name of a table's field.
GdaSqlAnyPart any ; |
inheritance structure |
gchar *field_name ; |
a table's field name, in the form [[[catalog.]schema.]table.]field_name |
void gda_sql_field_take_name (GdaSqlField *field, GValue *value);
field : |
|
value : |
typedef struct { GdaSqlAnyPart any; gchar *table_name; /* GdaMetaStore check */ gpointer full_table_name; } GdaSqlTable;
This structure represents the name of a table.
GdaSqlAnyPart any ; |
inheritance structure |
gchar *table_name ; |
a table's name, in the form [[catalog.]schema.]table |
gpointer full_table_name ; |
void gda_sql_table_take_name (GdaSqlTable *table, GValue *value);
table : |
|
value : |
typedef struct { GdaSqlAnyPart any; gchar *function_name; GSList *args_list; /* GdaDict check */ gchar *full_function_name; } GdaSqlFunction;
This structure represents a function or an aggregate with zero or more arguments.
GdaSqlAnyPart any ; |
inheritance structure |
gchar *function_name ; |
name of the function , in the form [[catalog.]schema.]function_name |
GSList *args_list ; |
list of GdaSqlExpr expressions, one for each argument |
gchar *full_function_name ; |
GdaSqlFunction* gda_sql_function_new (GdaSqlAnyPart *parent);
parent : |
|
Returns : |
GdaSqlFunction* gda_sql_function_copy (GdaSqlFunction *function);
function : |
|
Returns : |
gchar* gda_sql_function_serialize (GdaSqlFunction *function);
function : |
|
Returns : |
void gda_sql_function_take_name (GdaSqlFunction *function, GValue *value);
function : |
|
value : |
void gda_sql_function_take_args_list (GdaSqlFunction *function, GSList *args);
function : |
|
args : |
typedef struct { GdaSqlAnyPart any; GdaSqlOperator operator; GSList *operands; } GdaSqlOperation;
This structure represents an operation between one or more operands
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlOperator operator ; |
type of operation |
GSList *operands ; |
list of GdaSqlExpr operands |
typedef enum { GDA_SQL_OPERATOR_AND, GDA_SQL_OPERATOR_OR, GDA_SQL_OPERATOR_EQ, GDA_SQL_OPERATOR_IS, GDA_SQL_OPERATOR_LIKE, GDA_SQL_OPERATOR_BETWEEN, GDA_SQL_OPERATOR_GT, GDA_SQL_OPERATOR_LT, GDA_SQL_OPERATOR_GEQ, GDA_SQL_OPERATOR_LEQ, GDA_SQL_OPERATOR_DIFF, GDA_SQL_OPERATOR_REGEXP, GDA_SQL_OPERATOR_REGEXP_CI, GDA_SQL_OPERATOR_NOT_REGEXP, GDA_SQL_OPERATOR_NOT_REGEXP_CI, GDA_SQL_OPERATOR_SIMILAR, GDA_SQL_OPERATOR_ISNULL, GDA_SQL_OPERATOR_ISNOTNULL, GDA_SQL_OPERATOR_NOT, GDA_SQL_OPERATOR_IN, GDA_SQL_OPERATOR_NOTIN, GDA_SQL_OPERATOR_CONCAT, GDA_SQL_OPERATOR_PLUS, GDA_SQL_OPERATOR_MINUS, GDA_SQL_OPERATOR_STAR, GDA_SQL_OPERATOR_DIV, GDA_SQL_OPERATOR_REM, GDA_SQL_OPERATOR_BITAND, GDA_SQL_OPERATOR_BITOR, GDA_SQL_OPERATOR_BITNOT } GdaSqlOperator;
GdaSqlOperation* gda_sql_operation_new (GdaSqlAnyPart *parent);
parent : |
|
Returns : |
GdaSqlOperation* gda_sql_operation_copy (GdaSqlOperation *operation);
operation : |
|
Returns : |
gchar* gda_sql_operation_serialize (GdaSqlOperation *operation);
operation : |
|
Returns : |
const gchar* gda_sql_operation_operator_to_string (GdaSqlOperator op);
op : |
|
Returns : |
GdaSqlOperator gda_sql_operation_operator_from_string (const gchar *op);
op : |
|
Returns : |
typedef struct { GdaSqlAnyPart any; GdaSqlExpr *base_expr; GSList *when_expr_list; GSList *then_expr_list; GdaSqlExpr *else_expr; } GdaSqlCase;
This structure represents a CASE WHEN... construct
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlExpr *base_expr ; |
expression to test |
GSList *when_expr_list ; |
list of GdaSqlExpr, one for each WHEN clause |
GSList *then_expr_list ; |
list of GdaSqlExpr, one for each THEN clause |
GdaSqlExpr *else_expr ; |
default expression for the CASE |
typedef struct { 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; /* GdaDict check */ gchar *full_table_name; } GdaSqlSelectField;
This structure represents a selected item in a SELECT statement (when executed, the returned data set will have one column per selected item).
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlExpr *expr ; |
expression |
gchar *field_name ; |
field name part of expr if expr represents a field
|
gchar *table_name ; |
table name part of expr if expr represents a field
|
gchar *as ; |
alias |
gchar *full_table_name ; |
GdaSqlSelectField* gda_sql_select_field_new (GdaSqlAnyPart *parent);
parent : |
|
Returns : |
GdaSqlSelectField* gda_sql_select_field_copy (GdaSqlSelectField *field);
field : |
|
Returns : |
gchar* gda_sql_select_field_serialize (GdaSqlSelectField *field);
field : |
|
Returns : |
void gda_sql_select_field_take_star_value (GdaSqlSelectField *field, GValue *value);
field : |
|
value : |
void gda_sql_select_field_take_expr (GdaSqlSelectField *field, GdaSqlExpr *expr);
field : |
|
expr : |
void gda_sql_select_field_take_alias (GdaSqlSelectField *field, GValue *alias);
field : |
|
alias : |
typedef struct { GdaSqlAnyPart any; GdaSqlExpr *expr; gchar *table_name; /* may be NULL if expr does not refer to a table */ gchar *as; /* GdaDict check */ gchar *full_table_name; } GdaSqlSelectTarget;
This structure represents a target used to fetch data from in a SELECT statement; it can represent a table or a sub select.
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlExpr *expr ; |
expression |
gchar *table_name ; |
table name part of expr if expr represents a table
|
gchar *as ; |
alias |
gchar *full_table_name ; |
GdaSqlSelectTarget* gda_sql_select_target_new (GdaSqlAnyPart *parent);
parent : |
|
Returns : |
void gda_sql_select_target_free (GdaSqlSelectTarget *target);
target : |
GdaSqlSelectTarget* gda_sql_select_target_copy (GdaSqlSelectTarget *target);
target : |
|
Returns : |
gchar* gda_sql_select_target_serialize (GdaSqlSelectTarget *target);
target : |
|
Returns : |
void gda_sql_select_target_take_table_name (GdaSqlSelectTarget *target, GValue *value);
target : |
|
value : |
void gda_sql_select_target_take_select (GdaSqlSelectTarget *target, GdaSqlStatement *stmt);
target : |
|
stmt : |
void gda_sql_select_target_take_alias (GdaSqlSelectTarget *target, GValue *alias);
target : |
|
alias : |
typedef struct { GdaSqlAnyPart any; GdaSqlSelectJoinType type; gint position; /* between a target at (pos < @position) and the one @position */ GdaSqlExpr *expr; GSList *using; } GdaSqlSelectJoin;
This structure represents a join between two targets in a SELECT statement.
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlSelectJoinType type ; |
type of join |
gint position ; |
represents a join between a target at (pos < position ) and the one at position
|
GdaSqlExpr *expr ; |
joining expression |
GSList *using ; |
list of GdaSqlField identifying the columns the join is on |
GdaSqlSelectJoin* gda_sql_select_join_new (GdaSqlAnyPart *parent);
parent : |
|
Returns : |
GdaSqlSelectJoin* gda_sql_select_join_copy (GdaSqlSelectJoin *join);
join : |
|
Returns : |
gchar* gda_sql_select_join_serialize (GdaSqlSelectJoin *join);
join : |
|
Returns : |
const gchar* gda_sql_select_join_type_to_string (GdaSqlSelectJoinType type);
type : |
|
Returns : |
typedef struct { GdaSqlAnyPart any; GSList *targets; GSList *joins; } GdaSqlSelectFrom;
This structure represents the FROM clause of a SELECT statement, it lists targets and joins
GdaSqlAnyPart any ; |
inheritance structure |
GSList *targets ; |
list of GdaSqlSelectTarget |
GSList *joins ; |
list of GdaSqlSelectJoin |
GdaSqlSelectFrom* gda_sql_select_from_new (GdaSqlAnyPart *parent);
parent : |
|
Returns : |
GdaSqlSelectFrom* gda_sql_select_from_copy (GdaSqlSelectFrom *from);
from : |
|
Returns : |
gchar* gda_sql_select_from_serialize (GdaSqlSelectFrom *from);
from : |
|
Returns : |
void gda_sql_select_from_take_new_target (GdaSqlSelectFrom *from, GdaSqlSelectTarget *target);
from : |
|
target : |
void gda_sql_select_from_take_new_join (GdaSqlSelectFrom *from, GdaSqlSelectJoin *join);
from : |
|
join : |
typedef struct { GdaSqlAnyPart any; GdaSqlExpr *expr; gboolean asc; gchar *collation_name; } GdaSqlSelectOrder;
This structure represents the ordering of a SELECT statement
GdaSqlAnyPart any ; |
inheritance structure |
GdaSqlExpr *expr ; |
expression to order on |
gboolean asc ; |
TRUE is ordering is ascending |
gchar *collation_name ; |
name of the collation to use for ordering |
GdaSqlSelectOrder* gda_sql_select_order_new (GdaSqlAnyPart *parent);
parent : |
|
Returns : |
GdaSqlSelectOrder* gda_sql_select_order_copy (GdaSqlSelectOrder *order);
order : |
|
Returns : |
gchar* gda_sql_select_order_serialize (GdaSqlSelectOrder *order);
order : |
|
Returns : |