gda_g_type_to_string ()

const gchar *
gda_g_type_to_string (GType type);

Converts a GType to its string representation (use gda_g_type_from_string() for the operation in the other direction).

This function wraps g_type_name() but for common types it provides an easier to understand and remember name. For Example the G_TYPE_STRING is converted to "string" whereas g_type_name() converts it to "gchararray".

gda_g_type_from_string ()

GType
gda_g_type_from_string (const gchar *str);

Converts a named type to ts GType type (also see the gda_g_type_to_string() function).

This function is a wrapper around the g_type_from_name() function, but also recognizes some type synonyms such as:

gda_default_escape_string ()

gchar *
gda_default_escape_string (const gchar *string);

Escapes string to make it understandable by a DBMS. The escape method is very common and replaces any occurrence of "'" with "''" and "\" with "\"

gda_default_unescape_string ()

gchar *
gda_default_unescape_string (const gchar *string);

Do the reverse of gda_default_escape_string(): transforms any "''" into "'", any "\" into "\" and any "\'" into "'".

gda_identifier_hash ()

guint
gda_identifier_hash (const gchar *id);

computes a hash string from id , to be used in hash tables as a GHashFunc

gda_identifier_equal ()

gboolean
gda_identifier_equal (const gchar *id1,
                      const gchar *id2);

Does the same as strcmp(id1 , id2 ), but handles the case where id1 and/or id2 are enclosed in double quotes. can also be used in hash tables as a GEqualFunc.

gda_completion_list_get ()

gchar **
gda_completion_list_get (GdaConnection *cnc,
                         const gchar *sql,
                         gint start,
                         gint end);

Creates an array of strings (terminated by a NULL) corresponding to possible completions. If no completion is available, then the returned array contains just one NULL entry, and if it was not possible to try to compute a completions list, then NULL is returned.

gda_sql_identifier_split ()

gchar **
gda_sql_identifier_split (const gchar *id);

Splits id into an array of it sub parts. id 's format has to be "<part>[.<part>[...]]" where each part is either a text surrounded by double quotes which can contain upper and lower cases or an SQL identifier in lower case.

For example the "test.\"ATable\"" string will result in the array: {"test", "\"ATable\"", NULL}

gda_sql_identifier_quote ()

gchar *
gda_sql_identifier_quote (const gchar *id,
                          GdaConnection *cnc,
                          GdaServerProvider *prov,
                          gboolean meta_store_convention,
                          gboolean force_quotes);

Use this function for any SQL identifier to make sure that:

The force_quotes allow some control of how to interpret id : if FALSE, then id will be left unchanged most of the time (except for example if it's a reserved keyword), otherwise if force_quotes is TRUE, then the returned string will most probably have quotes around it to request that the database keep the case sensitiveness (but again, this may vary depending on the database being accessed through cnc ).

For example, the following table gives the result of this function depending on the arguments when cnc is NULL (and prov is also NULL):

Here are a few examples of when and how to use this function:

Note that id must not be a composed SQL identifier (such as "mytable.mycolumn" which should be treated as the "mytable" and "mycolumn" SQL identifiers). If unsure, use gda_sql_identifier_split().

Also note that if cnc is NULL, then it's possible to pass an non NULL prov to have a result specific to prov .

For more information, see the SQL identifiers and abstraction and

SQL identifiers in meta data sections.

Since: 4.0.3

gda_utility_check_data_model ()

gboolean
gda_utility_check_data_model (GdaDataModel *model,
                              gint nbcols,
                              ...);

Check the column types of a GdaDataModel.

gda_utility_check_data_model_v ()

gboolean
gda_utility_check_data_model_v (GdaDataModel *model,
                                gint nbcols,
                                GType *types);

Check the column types of a GdaDataModel.

[rename-to gda_utility_check_data_model]

Since: 4.2.6

gda_utility_data_model_dump_data_to_xml ()

gboolean
gda_utility_data_model_dump_data_to_xml
                               (GdaDataModel *model,
                                xmlNodePtr parent,
                                const gint *cols,
                                gint nb_cols,
                                const gint *rows,
                                gint nb_rows,
                                gboolean use_col_ids);

Dump the data in a GdaDataModel into a xmlNodePtr (as used in libxml).

Warning: this function uses a GdaDataModelIter iterator, and if model does not offer a random access (check using gda_data_model_get_access_flags()), the iterator will be the same as normally used to access data in model previously to calling this method, and this iterator will be moved (point to another row).

gda_utility_data_model_find_column_description ()

const gchar *
gda_utility_data_model_find_column_description
                               (GdaDataSelect *model,
                                const gchar *field_name);

Finds the description of a field into Metadata from a GdaDataModel.

gda_utility_holder_load_attributes ()

gboolean
gda_utility_holder_load_attributes (GdaHolder *holder,
                                    xmlNodePtr node,
                                    GSList *sources,
                                    GError **error);

Note: this method may set the "source" custom string property

gda_statement_rewrite_for_default_values ()

GdaSqlStatement *
gda_statement_rewrite_for_default_values
                               (GdaStatement *stmt,
                                GdaSet *params,
                                gboolean remove,
                                GError **error);

Rewrites stmt and creates a new GdaSqlStatement where all the variables which are to a DEFAULT value (as returned by gda_holder_value_is_default()) are either removed from the statement (if remove is TRUE) or replaced by the "DEFAULT" keyword (if remove is FALSE).

This function is only useful for database providers' implementations which have to deal with default values when executing statements, and is only relevant in the case of INSERT or UPDATE statements (in the latter case an error is returned if remove is TRUE).

For example the

INSERT INTO mytable (id, name) VALUES (23, ##name::string)

is re-written into

INSERT INTO mytable (id, name) VALUES (23, DEFAULT)

if remove is FALSE and into

INSERT INTO mytable (id) VALUES (23)

if remove is TRUE.

Since: 4.2

gda_text_to_alphanum ()

gchar *
gda_text_to_alphanum (const gchar *text);

The "encoding" consists in replacing non alphanumeric character with the string "__gdaXX" where XX is the hex. representation of the non alphanumeric char.

gda_alphanum_to_text ()

gchar *
gda_alphanum_to_text (gchar *text);

Does the opposite of gda_text_to_alphanum(), in the same string

gda_compute_unique_table_row_condition ()

GdaSqlExpr *
gda_compute_unique_table_row_condition
                               (GdaSqlStatementSelect *stsel,
                                GdaMetaTable *mtable,
                                gboolean require_pk,
                                GError **error);

Computes a GdaSqlExpr expression which can be used in the WHERE clause of an UPDATE or DELETE statement when a row from the result of the stsel statement has to be modified.

gda_compute_unique_table_row_condition_with_cnc ()

GdaSqlExpr *
gda_compute_unique_table_row_condition_with_cnc
                               (GdaConnection *cnc,
                                GdaSqlStatementSelect *stsel,
                                GdaMetaTable *mtable,
                                gboolean require_pk,
                                GError **error);

Computes a GdaSqlExpr expression which can be used in the WHERE clause of an UPDATE or DELETE statement when a row from the result of the stsel statement has to be modified.

If require_pk is TRUE then this function will return a non NULL GdaSqlExpr only if it can use a primary key of mtable . If require_pk is FALSE, then it will try to use a primary key of mtable , and if none is available, it will use all the columns of mtable to compute a condition statement.

Since: 4.0.3

gda_compute_dml_statements ()

gboolean
gda_compute_dml_statements (GdaConnection *cnc,
                            GdaStatement *select_stmt,
                            gboolean require_pk,
                            GdaStatement **insert_stmt,
                            GdaStatement **update_stmt,
                            GdaStatement **delete_stmt,
                            GError **error);

Creates an INSERT, an UPDATE and a DELETE statement from a SELECT statement using the database metadata available in cnc 's meta store. Each statements are computed only if the corresponding place to store the created statement is not NULL.

gda_compute_select_statement_from_update ()

GdaSqlStatement *
gda_compute_select_statement_from_update
                               (GdaStatement *update_stmt,
                                GError **error);

Computes a SELECT statement which selects all the rows the update_stmt would update. Beware however that this GdaSqlStatement does not select anything (ie it would be rendered as "SELECT FROM ... WHERE ...") and before being usable, one needs to add some fields to actually select.

gda_rewrite_sql_statement_for_null_parameters ()

GdaSqlStatement *
gda_rewrite_sql_statement_for_null_parameters
                               (GdaSqlStatement *sqlst,
                                GdaSet *params,
                                gboolean *out_modified,
                                GError **error);

Modifies sqlst to take into account any parameter which might be NULL: if sqlst contains the equivalent of "xxx = <parameter definition>" and if that parameter is in params and its value is of type GDA_TYPE_NUL, then that part is replaced with "xxx IS NULL". It also handles the "xxx IS NOT NULL" transformation.

If out_modified is not NULL, then it will be set to TRUE if sqlst has been modified by this function, and to FALSE otherwise.

This function is used by provider's implementations to make sure one can use parameters with NULL values in statements without having to rewrite statements, as database usually don't consider that "xxx = NULL" is the same as "xxx IS NULL" when using parameters.

Since: 4.2.9

gda_rewrite_statement_for_null_parameters ()

gboolean
gda_rewrite_statement_for_null_parameters
                               (GdaStatement *stmt,
                                GdaSet *params,
                                GdaStatement **out_stmt,
                                GError **error);

Modifies stmt to take into account any parameter which might be NULL: if stmt contains the equivalent of "xxx = <parameter definition>" and if that parameter is in params and its value is of type GDA_TYPE_NUL, then that part is replaced with "xxx IS NULL". It also handles the "xxx IS NOT NULL" transformation.

For example the following SELECT:

SELECT * FROM data WHERE id = ##id::int::null AND name = ##name::string

in case the "id" parameter is set to NULL, is converted to:

SELECT * FROM data WHERE id IS NULL AND name = ##name::string

if out_stmt is not NULL, then it will contain:

This function is used by provider's implementations to make sure one can use parameters with NULL values in statements without having to rewrite statements, as database usually don't consider that "xxx = NULL" is the same as "xxx IS NULL" when using parameters.

Since: 4.2.9

gda_rfc1738_encode ()

gchar *
gda_rfc1738_encode (const gchar *string);

Encodes string using the RFC 1738 recommendations: the

<>"#%{}|\^~[]'`;/?:@=& and space characters are replaced by "%ab" where ab is the hexadecimal number corresponding to the character.

gda_rfc1738_decode ()

gboolean
gda_rfc1738_decode (gchar *string);

Decodes string using the RFC 1738 recommendations: the

<>"#%{}|\^~[]'`;/?:@=& and space characters are replaced by "%ab" where ab is the hexadecimal number corresponding to the character.

string should respect the RFC 1738 encoding. If this is not the case (for example if there is a "2z" because 2z is not an hexadecimal value), then the part with the problem is not decoded, and the function returns FALSE.

string is decoded in place, no new string gets created.

gda_dsn_split ()

void
gda_dsn_split (const gchar *string,
               gchar **out_dsn,
               gchar **out_username,
               gchar **out_password);

Extract the DSN, username and password from string . in string , the various parts are strings which are expected to be encoded using an RFC 1738 compliant encoding. If they are specified, the returned username and password strings are correctly decoded.

out_username and out_password may be set to NULL depending on string 's format.

gda_connection_string_split ()

void
gda_connection_string_split (const gchar *string,
                             gchar **out_cnc_params,
                             gchar **out_provider,
                             gchar **out_username,
                             gchar **out_password);

Extract the provider, connection parameters, username and password from string . in string , the various parts are strings which are expected to be encoded using an RFC 1738 compliant encoding. If they are specified, the returned provider, username and password strings are correctly decoded.

For example all the following connection strings:

PostgreSQL://meme:pass@DB_NAME=mydb;HOST=server
PostgreSQL://meme@DB_NAME=mydb;HOST=server;PASSWORD=pass
PostgreSQL://meme@DB_NAME=mydb;PASSWORD=pass;HOST=server
PostgreSQL://meme@PASSWORD=pass;DB_NAME=mydb;HOST=server
PostgreSQL://DB_NAME=mydb;HOST=server;USERNAME=meme;PASSWORD=pass
PostgreSQL://DB_NAME=mydb;HOST=server;PASSWORD=pass;USERNAME=meme
PostgreSQL://DB_NAME=mydb;USERNAME=meme;PASSWORD=pass;HOST=server
PostgreSQL://PASSWORD=pass;USERNAME=meme;DB_NAME=mydb;HOST=server
PostgreSQL://:pass@USERNAME=meme;DB_NAME=mydb;HOST=server
PostgreSQL://:pass@DB_NAME=mydb;HOST=server;USERNAME=meme

will return the following new strings (double quotes added here to delimit strings):

out_cnc_params: "DB_NAME=mydb;HOST=server"
out_provider: "PostgreSQL"
out_username: "meme"
out_password: "pass"

gda_parse_iso8601_date ()

gboolean
gda_parse_iso8601_date (GDate *gdate,
                        const gchar *value);

Extracts date parts from value , and sets gdate 's contents

Accepted date format is "YYYY-MM-DD" (more or less than 4 digits for years and less than 2 digits for month and day are accepted). Years must be in the 1-65535 range, a limitation imposed by GDate.

gda_parse_iso8601_time ()

gboolean
gda_parse_iso8601_time (GdaTime *timegda,
                        const gchar *value);

Extracts time parts from value , and sets timegda 's contents

Accepted date format is "HH:MM:SS.ms" where TZ is +hour or -hour

gda_parse_iso8601_timestamp ()

GDateTime *
gda_parse_iso8601_timestamp (const gchar *value);

Extracts date and time parts from value , and sets timestamp 's contents

Accepted date format is "YYYY-MM-DDTHH:MM:SS.ms" where TZ is +hour or -hour

gda_parse_formatted_date ()

gboolean
gda_parse_formatted_date (GDate *gdate,
                          const gchar *value,
                          GDateDMY first,
                          GDateDMY second,
                          GDateDMY third,
                          gchar sep);

This function is similar to gda_parse_iso8601_date() (with first being G_DATE_YEAR , second being G_DATE_MONTH , third being G_DATE_DAY and sep being '-') but allows one to specify the expected date format.

Since: 5.2

gda_parse_formatted_time ()

gboolean
gda_parse_formatted_time (GdaTime *timegda,
                          const gchar *value,
                          gchar sep);

Since: 5.2

gda_parse_formatted_timestamp ()

GDateTime *
gda_parse_formatted_timestamp (const gchar *value,
                               GDateDMY first,
                               GDateDMY second,
                               GDateDMY third,
                               gchar sep);

This function is similar to gda_parse_iso8601_timestamp() (with first being G_DATE_YEAR , second being G_DATE_MONTH , third being G_DATE_DAY and sep being '-') but allows one to specify the expected date format.

Since: 5.2