gda_server_operation_new ()

GdaServerOperation * gda_server_operation_new           (GdaServerOperationType op_type,
                                                         const gchar *xml_file);

IMPORTANT NOTE: Using this funtion is not the recommended way of creating a GdaServerOperation object, the correct way is to use gda_server_provider_create_operation(); this method is reserved for the database provider's implementation.

Creates a new GdaServerOperation object from the xml_file specifications

The xml_file must respect the DTD described in the "libgda-server-operation.dtd" file: its top node must be a <serv_op> tag.

gda_server_provider_internal_get_parser ()

GdaSqlParser *      gda_server_provider_internal_get_parser
                                                        (GdaServerProvider *prov);

This is a factory method to get a unique instance of a GdaSqlParser object for each GdaServerProvider object Don't unref it.

gda_server_provider_perform_operation_default ()

gboolean            gda_server_provider_perform_operation_default
                                                        (GdaServerProvider *provider,
                                                         GdaConnection *cnc,
                                                         GdaServerOperation *op,
                                                         GError **error);

Performs the operation described by op, using the SQL from the rendering of the operation

gda_server_provider_get_data_handler_default ()

GdaDataHandler *    gda_server_provider_get_data_handler_default
                                                        (GdaServerProvider *provider,
                                                         GdaConnection *cnc,
                                                         GType type,
                                                         const gchar *dbms_type);

Provides the implementation when the default Libgda's data handlers must be used

gda_server_provider_handler_find ()

GdaDataHandler *    gda_server_provider_handler_find    (GdaServerProvider *prov,
                                                         GdaConnection *cnc,
                                                         GType g_type,
                                                         const gchar *dbms_type);

gda_server_provider_handler_declare ()

void                gda_server_provider_handler_declare (GdaServerProvider *prov,
                                                         GdaDataHandler *dh,
                                                         GdaConnection *cnc,
                                                         GType g_type,
                                                         const gchar *dbms_type);

gda_server_provider_find_file ()

gchar *             gda_server_provider_find_file       (GdaServerProvider *prov,
                                                         const gchar *inst_dir,
                                                         const gchar *filename);

Finds the location of a filename. This function should only be used by database provider's implementations

gda_server_provider_load_file_contents ()

gchar *             gda_server_provider_load_file_contents
                                                        (const gchar *inst_dir,
                                                         const gchar *data_dir,
                                                         const gchar *filename);

Loads and returns the contents of filename, which is searched in several places This function should only be used by database provider's implementations

gda_connection_internal_set_provider_data ()

void                gda_connection_internal_set_provider_data
                                                        (GdaConnection *cnc,
                                                         gpointer data,
                                                         GDestroyNotify destroy_func);

Note: calling this function more than once will not make it call destroy_func on any previously set opaque data, you'll have to do it yourself.

gda_connection_internal_get_provider_data ()

gpointer            gda_connection_internal_get_provider_data
                                                        (GdaConnection *cnc);

Get the opaque pointer previously set using gda_connection_internal_set_provider_data(). If it's not set, then add a connection event and returns NULL

gda_connection_add_event ()

void                gda_connection_add_event            (GdaConnection *cnc,
                                                         GdaConnectionEvent *event);

Adds an event to the given connection. This function is usually called by providers, to inform clients of events that happened during some operation.

As soon as a provider (or a client, it does not matter) calls this function with an event object which is an error, the connection object emits the "error" signal, to which clients can connect to be informed of events.

WARNING: the reference to the event object is stolen by this function!

gda_connection_add_event_string ()

GdaConnectionEvent * gda_connection_add_event_string    (GdaConnection *cnc,
                                                         const gchar *str,
                                                         ...);

Adds a new error to the given connection object. This is just a convenience function that simply creates a GdaConnectionEvent and then calls gda_server_connection_add_error.

gda_connection_clear_events_list ()

void                gda_connection_clear_events_list    (GdaConnection *cnc);

This function lets you clear the list of GdaConnectionEvent's of the given connection.

gda_connection_event_new ()

GdaConnectionEvent * gda_connection_event_new           (GdaConnectionEventType type);

Creates a new uninitialized event object. This class is used for communicating events from the different providers to the clients.

gda_connection_event_set_event_type ()

void                gda_connection_event_set_event_type (GdaConnectionEvent *event,
                                                         GdaConnectionEventType type);

Sets event's severity (from a simple notice to a fatal event) This function should not be called directly.

gda_connection_event_set_description ()

void                gda_connection_event_set_description
                                                        (GdaConnectionEvent *event,
                                                         const gchar *description);

Sets event's description. This function should not be called directly.

gda_connection_event_set_code ()

void                gda_connection_event_set_code       (GdaConnectionEvent *event,
                                                         glong code);

Sets event's code: the code is specific to the provider being used. If you want to have a common understanding of the event codes, use gda_connection_event_get_gda_code() instead.

This function should not be called directly

gda_connection_event_set_gda_code ()

void                gda_connection_event_set_gda_code   (GdaConnectionEvent *event,
                                                         GdaConnectionEventCode code);

Sets event's gda code: that code is standardized by the libgda library. If you want to specify the corresponding provider specific code, use gda_connection_event_get_code() or gda_connection_event_get_sqlstate() instead.

This function should not be called directly

gda_connection_event_set_source ()

void                gda_connection_event_set_source     (GdaConnectionEvent *event,
                                                         const gchar *source);

Sets event's source; this function should not be called directly

gda_connection_event_set_sqlstate ()

void                gda_connection_event_set_sqlstate   (GdaConnectionEvent *event,
                                                         const gchar *sqlstate);

Changes the SQLSTATE code of event, this function should not be called directly

Sets event's SQL state.

gda_connection_add_prepared_statement ()

void                gda_connection_add_prepared_statement
                                                        (GdaConnection *cnc,
                                                         GdaStatement *gda_stmt,
                                                         GdaPStmt *prepared_stmt);

Declares that prepared_stmt is a prepared statement object associated to gda_stmt within the connection (meaning the connection increments the reference counter of prepared_stmt).

If gda_stmt changes or is destroyed, the the association will be lost and the connection will lose the reference it has on prepared_stmt.

gda_connection_del_prepared_statement ()

void                gda_connection_del_prepared_statement
                                                        (GdaConnection *cnc,
                                                         GdaStatement *gda_stmt);

Removes any prepared statement associated to gda_stmt in cnc: this undoes what gda_connection_add_prepared_statement() does.

gda_connection_get_prepared_statement ()

GdaPStmt *          gda_connection_get_prepared_statement
                                                        (GdaConnection *cnc,
                                                         GdaStatement *gda_stmt);

Retrieves a pointer to an object representing a prepared statement for gda_stmt within cnc. The association must have been done using gda_connection_add_prepared_statement().

gda_connection_internal_transaction_started ()

void                gda_connection_internal_transaction_started
                                                        (GdaConnection *cnc,
                                                         const gchar *parent_trans,
                                                         const gchar *trans_name,
                                                         GdaTransactionIsolation isol_level);

Internal functions to be called by database providers when a transaction has been started to keep track of the transaction status of the connection.

Note: this function should not be called if gda_connection_internal_statement_executed() has already been called because a statement's execution was necessary to perform the action.

gda_connection_internal_transaction_rolledback ()

void                gda_connection_internal_transaction_rolledback
                                                        (GdaConnection *cnc,
                                                         const gchar *trans_name);

Internal functions to be called by database providers when a transaction has been rolled back to keep track of the transaction status of the connection

Note: this function should not be called if gda_connection_internal_statement_executed() has already been called because a statement's execution was necessary to perform the action.

gda_connection_internal_transaction_committed ()

void                gda_connection_internal_transaction_committed
                                                        (GdaConnection *cnc,
                                                         const gchar *trans_name);

Internal functions to be called by database providers when a transaction has been committed to keep track of the transaction status of the connection

Note: this function should not be called if gda_connection_internal_statement_executed() has already been called because a statement's execution was necessary to perform the action.

gda_connection_internal_statement_executed ()

void                gda_connection_internal_statement_executed
                                                        (GdaConnection *cnc,
                                                         GdaStatement *stmt,
                                                         GdaSet *params,
                                                         GdaConnectionEvent *error);

Internal functions to be called by database providers when a statement has been executed to keep track of the transaction status of the connection

gda_connection_internal_savepoint_added ()

void                gda_connection_internal_savepoint_added
                                                        (GdaConnection *cnc,
                                                         const gchar *parent_trans,
                                                         const gchar *svp_name);

Internal functions to be called by database providers when a savepoint has been added to keep track of the transaction status of the connection

Note: this function should not be called if gda_connection_internal_statement_executed() has already been called because a statement's execution was necessary to perform the action.

gda_connection_internal_savepoint_rolledback ()

void                gda_connection_internal_savepoint_rolledback
                                                        (GdaConnection *cnc,
                                                         const gchar *svp_name);

Internal functions to be called by database providers when a savepoint has been rolled back to keep track of the transaction status of the connection

Note: this function should not be called if gda_connection_internal_statement_executed() has already been called because a statement's execution was necessary to perform the action.

gda_connection_internal_savepoint_removed ()

void                gda_connection_internal_savepoint_removed
                                                        (GdaConnection *cnc,
                                                         const gchar *svp_name);

Internal functions to be called by database providers when a savepoint has been removed to keep track of the transaction status of the connection

Note: this function should not be called if gda_connection_internal_statement_executed() has already been called because a statement's execution was necessary to perform the action.

gda_connection_internal_change_transaction_state ()

void                gda_connection_internal_change_transaction_state
                                                        (GdaConnection *cnc,
                                                         GdaTransactionStatusState newstate);

Internal function to be called by database providers to force a transaction status change.

gda_connection_internal_reset_transaction_status ()

void                gda_connection_internal_reset_transaction_status
                                                        (GdaConnection *cnc);

Internal function to be called by database providers to reset the transaction status.

gda_connection_open_sqlite ()

GdaConnection *     gda_connection_open_sqlite          (const gchar *directory,
                                                         const gchar *filename,
                                                         gboolean auto_unlink);

Opens an SQLite connection even if the SQLite provider is not installed, to be used by database providers which need a temporary database to store some information.

gda_meta_store_modify ()

gboolean            gda_meta_store_modify               (GdaMetaStore *store,
                                                         const gchar *table_name,
                                                         GdaDataModel *new_data,
                                                         const gchar *condition,
                                                         GError **error,
                                                         ...);

Propagates an update to store, the update's contents is represented by new_data, this function is primarily reserved to database providers.

For example tell store to update its list of tables, new_data should contain the same columns as the "_tables" table of store, and contain one row per table in the store; there should not be any more argument after the error argument.

Now, to update only one table, the new_data data model should have one row for the table to update (or no row at all if the table does not exist anymore), and have values for the primary key of the "_tables" table of store, namely "table_catalog", "table_schema" and "table_name".

gda_meta_store_modify_v ()

gboolean            gda_meta_store_modify_v             (GdaMetaStore *store,
                                                         const gchar *table_name,
                                                         GdaDataModel *new_data,
                                                         const gchar *condition,
                                                         gint nvalues,
                                                         const gchar **value_names,
                                                         const GValue **values,
                                                         GError **error);

Propagates an update to store, the update's contents is represented by new_data, this function is primarily reserved to database providers.

Since 4.2.6

gda_meta_store_modify_with_context ()

gboolean            gda_meta_store_modify_with_context  (GdaMetaStore *store,
                                                         GdaMetaContext *context,
                                                         GdaDataModel *new_data,
                                                         GError **error);

Propagates an update to store, the update's contents is represented by new_data, this function is primarily reserved to database providers.

enum GdaSqlIdentifierStyle

typedef enum {
	GDA_SQL_IDENTIFIERS_LOWER_CASE = 1 << 0,
	GDA_SQL_IDENTIFIERS_UPPER_CASE = 1 << 1
} GdaSqlIdentifierStyle;

Specifies how SQL identifiers are represented by a specific database.

gda_meta_store_set_identifiers_style ()

void                gda_meta_store_set_identifiers_style
                                                        (GdaMetaStore *store,
                                                         GdaSqlIdentifierStyle style);

Specifies how store must handle SQL identifiers it has to store. This method is mainly used by database providers.

Since 4.2

GdaSqlReservedKeywordsFunc ()

gboolean            (*GdaSqlReservedKeywordsFunc)       (const gchar *word);

gda_meta_store_set_reserved_keywords_func ()

void                gda_meta_store_set_reserved_keywords_func
                                                        (GdaMetaStore *store,
                                                         GdaSqlReservedKeywordsFunc func);

Specifies a function which store will use to determine if a keyword is an SQL reserved keyword or not.

This method is mainly used by database providers.

Since 4.2

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.

FALSE will be returned if any of the statement cannot be built.

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_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.

REM: the case where require_pk is FALSE is not currently implemented.

Since 4.0.3

gda_sql_any_part_check_structure ()

gboolean            gda_sql_any_part_check_structure    (GdaSqlAnyPart *node,
                                                         GError **error);

Checks for any error in node's structure to make sure it is valid. This is the same as gda_sql_statement_check_structure() but for individual GdaSqlAnyPart parts. This function is mainly for database provider's implementations

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