gda.c.types

Used in [gda.connection.Connection.supportsFeature] and [gda.server_provider.ServerProvider.supportsFeature] to test if a connection or a database provider supports some specific feature.

Used with [gda.connection.Connection.getMetaStoreData] to describe what meta data to extract from a connection's associated #GdaMetaStore.

Specifies some aspects of a connection when opening it.

Additional information about the GDA_CONNECTION_OPTIONS_SQL_IDENTIFIERS_CASE_SENSITIVE flag:

name specified in a #GdaServerOperation to create a table is

as <emphasis>MyTable</emphasis> (note that in the end the database may still decide to name the table <emphasis>mytable</emphasis> or differently if it can't do otherwise).</para></listitem>

has to be conform to the database it will be used with</para></listitem>

Additional information about the GDA_CONNECTION_OPTIONS_THREAD_SAFE and GDA_CONNECTION_OPTIONS_THREAD_ISOLATED flags: The GDA_CONNECTION_OPTIONS_THREAD_SAFE flag specifies that it has to be able to use the returned connection object from several threads at once (locking is ensured by the #GdaConnection itself). Depending on the database provider's implementation and on the native libraries it uses, the "normal" connection object might not respect this requirement, and in this case a specific thread is started and used as the unique thread which will manipulate the actual connection, while a "wrapper connection" is actually returned and used by the caller (that wrapper connection passes method calls from the calling thread to the actual connection's specific thread, and gets the results back).

The GDA_CONNECTION_OPTIONS_THREAD_ISOLATED forces using a specific thread and a "wrapper connection" even if the "normal" connection would itself be thread safe; this is useful for example to be sure the asynchronous API can always be used (see [gda.connection.Connection.asyncStatementExecute]).

Having a specific thread and a "wrapper connection" definitely has an impact on the performances (because it involves messages passing between threads for every method call), so using the GDA_CONNECTION_OPTIONS_THREAD_SAFE or GDA_CONNECTION_OPTIONS_THREAD_ISOLATED flags should be carefully considered.

Note about the @GDA_CONNECTION_OPTIONS_AUTO_META_DATA flag:

defined, will be updated, which has a impact on performances</para></listitem>

is not rolled back or committed, then the meta data may end up being wrong</para></listitem>

Format to use when exporting a data model, see [gda.data_model.DataModel.exportToString] and [gda.data_model.DataModel.exportToFile]

Possible operations for the data fields.

Possible #GdaDataPivot related errors.

Define types of field to be used when defining a #GdaDataPivot analysis.

Defines what criteria [gda.data_select.DataSelect.computeModificationStatementsExt] uses to uniquely identify a single row in a table when creating modification statements.

Type of database object which can be handled as a #GdaMetaDbObject

Defines the filtering policy of a foreign key when invoked on an UPDATE or DELETE operation.

Types of sorting

Controls which features are computed about database objects.

Type of part.

Specifies how SQL identifiers are represented by a specific database

Known types of statements

These flags specify how the #GdaDataModel returned when executing a #GdaStatement will be used

Specifies rendering options

Defines the kind of notification which can be obtained when reading from te #GIOChannel returned by [gda.thread_wrapper.ThreadWrapper.getIoChannel].

Represents some binary data, accessed through a #GdaBlobOp object. @op is generally set up by database providers when giving access to an existing BLOB in a database, but can be modified if needed using [gda.blob.Blob.setOp].

This structure defines the properties of a named data source (DSN).

The <structname>GdaMetaContext</structname> represents a meta data modification context: the <emphasis>how</emphasis> when used with [gda.meta_store.MetaStore.modifyWithContext], and the <emphasis>what</emphasis> when used with [gda.connection.Connection.updateMetaStore].

To create a new #GdaMetaContext use #gda_meta_context_new.

To add a new column/value pair use #gda_meta_context_add_column.

To free a #GdaMetaContext, created by #gda_meta_context_new, use #gda_attributes_manager_free.

Since 5.2, you must consider this struct as opaque. Any access to its internal must use public API. Don't try to use #gda_meta_context_free on a struct that was created manually.

Struture to hold information about each database object (tables, views, ...), its contents must not be modified.

This structure specifies a #GdaMetaDbObject to represent a table's specific attributes, its contents must not be modified.

Note that in some cases, the columns cannot be determined for views, and in this case the @columns will be null (this can be the case for example with SQLite where a view uses a function which is not natively provided by SQLite.

This structure represents a table of view's column, its contents must not be modified.

This structure represents a foreign key constraint, its contents must not be modified.

This structure specifies a #GdaMetaDbObject to represent a view's specific attributes, its contents must not be modified.

Holds numbers represented as strings.

This struct must be considered as opaque. Any access to its members must use its accessors added since version 5.0.2.

This structure holds the information associated to a database provider as discovered by Libgda.

These methods must be implemented by providers to update a connection's associated metadata (in a #GdaMetaStore object), see the <link linkend="prov-metadata">Virtual methods for providers/Methods - metadata</link> for more information.

Since 5.2, you must consider this struct as opaque. Any access to its internal must use public API. Don't try to use #gda_set_group_free on a struct that was created manually.

Since 5.2, you must consider this struct as opaque. Any access to its internal must use public API. Don't try to use #gda_set_node_free on a struct that was created manually.

Since 5.2, you must consider this struct as opaque. Any access to its internal must use public API. Don't try to use #gda_set_source_free on a struct that was created manually.

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

This structure represents a CASE WHEN... construct

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 <userinput>'joe'</userinput> 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.

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

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

This structure represents an operation between one or more operands.

Specifies the context in which a #GdaSqlStatement is being converted to SQL.

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 <emphasis>will be</emphasis> overwritten by &LIBGDA;, set the value of @expr->value instead.

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

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

This structure represents the ordering of a SELECT statement.

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 <emphasis>will be</emphasis> overwritten by &LIBGDA;, set the value of @expr->value instead.

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

Validation against a dictionary

Contents' infos

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.

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.

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

This structure represents the name of a table.

A notification to be read through the #GIOChannel which is returned by [gda.thread_wrapper.ThreadWrapper.getIoChannel], for example:

gboolean wrapper_ioc_cb (GIOChannel *source, GIOCondition condition, gpointer data) { GIOStatus status; gsize nread; GdaThreadNotification notif; if (condition & G_IO_IN) { status = g_io_channel_read_chars (source, (gchar*) &notif, sizeof (notif), &nread, NULL); if ((status != G_IO_STATUS_NORMAL) || (nread != sizeof (notif))) goto onerror; switch (notif.type) { case GDA_THREAD_NOTIFICATION_JOB: check_for_wrapper_result (bcnc); break; case GDA_THREAD_NOTIFICATION_SIGNAL: gda_thread_wrapper_iterate (bcnc->priv->wrapper, FALSE); break; default: goto onerror; break; } } if (condition & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) goto onerror; return TRUE; // keep callback

onerror: g_io_channel_shutdown (bcnc->priv->ioc, FALSE, NULL); return FALSE; // removed callback }

{ [...] GIOChannel *ioc; ioc = gda_thread_wrapper_get_io_channel (wrapper); if (!ioc) [handle error] else { guint watch_id; watch_id = g_io_add_watch (ioc, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL, (GIOFunc) wrapper_ioc_cb, NULL); } } ]]></programlisting>

Represents a time information.

Represents an instant (a time stamp)