gda_meta_store_error_quark ()

GQuark
gda_meta_store_error_quark (void);

gda_meta_store_change_new ()

GdaMetaStoreChange *
gda_meta_store_change_new (void);

Creates a new GdaMetaStoreChange

gda_meta_store_change_set_change_type ()

void
gda_meta_store_change_set_change_type (GdaMetaStoreChange *change,
                                       GdaMetaStoreChangeType ctype);

gda_meta_store_change_get_change_type ()

GdaMetaStoreChangeType
gda_meta_store_change_get_change_type (GdaMetaStoreChange *change);

gda_meta_store_change_set_table_name ()

void
gda_meta_store_change_set_table_name (GdaMetaStoreChange *change,
                                      const gchar *table_name);

gda_meta_store_change_get_table_name ()

gchar *
gda_meta_store_change_get_table_name (GdaMetaStoreChange *change);

gda_meta_store_change_get_keys ()

GHashTable *
gda_meta_store_change_get_keys (GdaMetaStoreChange *change);

gda_meta_store_change_copy ()

GdaMetaStoreChange *
gda_meta_store_change_copy (GdaMetaStoreChange *src);

gda_meta_store_change_free ()

void
gda_meta_store_change_free (GdaMetaStoreChange *change);

gda_value_set_meta_store_change ()

void
gda_value_set_meta_store_change (GValue *value,
                                 GdaMetaStoreChange *change);

gda_value_get_meta_store_change ()

GdaMetaStoreChange *
gda_value_get_meta_store_change (GValue *value);

gda_meta_store_new_with_file ()

GdaMetaStore *
gda_meta_store_new_with_file (const gchar *file_name);

Create a new GdaMetaStore object using file_name as its internal database

gda_meta_store_new ()

GdaMetaStore *
gda_meta_store_new (const gchar *cnc_string);

Create a new GdaMetaStore object.

gda_meta_store_get_version ()

gint
gda_meta_store_get_version (GdaMetaStore *store);

Get store 's internal schema's version

gda_meta_store_get_internal_connection ()

GdaConnection *
gda_meta_store_get_internal_connection
                               (GdaMetaStore *store);

Get a pointer to the GdaConnection object internally used by store to store its contents.

The returned connection can be used to access some other data than the one managed by store itself. The returned object is not owned by the caller (if you need to keep it, then use g_object_ref()). Do not close the connection.

gda_meta_store_sql_identifier_quote ()

gchar *
gda_meta_store_sql_identifier_quote (const gchar *id,
                                     GdaConnection *cnc);

Use this method to get a correctly quoted (if necessary) SQL identifier which can be used to retrieve or filter information in a GdaMetaStore which stores meta data about cnc .

The returned SQL identifier can be used in conjunction with gda_connection_update_meta_store(), gda_connection_get_meta_store_data(), gda_connection_get_meta_store_data_v() and gda_meta_store_extract().

Since: 4.0.3

gda_meta_store_extract ()

GdaDataModel *
gda_meta_store_extract (GdaMetaStore *store,
                        const gchar *select_sql,
                        GError **error,
                        ...);

Extracts some data stored in store using a custom SELECT query. If the select_sql filter involves SQL identifiers (such as table or column names), then the values should have been adapted using gda_meta_store_sql_identifier_quote().

For more information about SQL identifiers are represented in store , see the

gda_meta_store_extract_v ()

GdaDataModel *
gda_meta_store_extract_v (GdaMetaStore *store,
                          const gchar *select_sql,
                          GHashTable *vars,
                          GError **error);

Extracts some data stored in store using a custom SELECT query. If the select_sql filter involves SQL identifiers (such as table or column names), then the values should have been adapted using gda_meta_store_sql_identifier_quote().

For more information about SQL identifiers are represented in store , see the

[rename-to gda_meta_store_extract]

Since: 4.2.6

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.

[rename-to gda_meta_store_modify]

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.

gda_meta_store_create_modify_data_model ()

GdaDataModel *
gda_meta_store_create_modify_data_model
                               (GdaMetaStore *store,
                                const gchar *table_name);

Creates a new GdaDataModelArray data model which can be used, after being correctly filled, with the gda_meta_store_modify*() methods.*

To be used by provider's implementation

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

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_meta_store_get_attribute_value ()

gboolean
gda_meta_store_get_attribute_value (GdaMetaStore *store,
                                    const gchar *att_name,
                                    gchar **att_value,
                                    GError **error);

The GdaMetaStore object maintains a list of (name,value) attributes (attributes names starting with a '_' character are for internal use only and cannot be altered). This method and the gda_meta_store_set_attribute_value() method allows the user to add, set or remove attributes specific to their usage.

This method allows to get the value of a attribute stored in store . The returned attribute value is placed at att_value , the caller is responsible for free that string.

If there is no attribute named att_name then att_value is set to NULL and error will contain the GDA_META_STORE_ATTRIBUTE_NOT_FOUND_ERROR error code, and FALSE is returned.

gda_meta_store_set_attribute_value ()

gboolean
gda_meta_store_set_attribute_value (GdaMetaStore *store,
                                    const gchar *att_name,
                                    const gchar *att_value,
                                    GError **error);

Set the value of the attribute named att_name to att_value ; see gda_meta_store_get_attribute_value() for more information.

gda_meta_store_schema_add_custom_object ()

gboolean
gda_meta_store_schema_add_custom_object
                               (GdaMetaStore *store,
                                const gchar *xml_description,
                                GError **error);

The internal database used by store can be 'augmented' with some user-defined database objects (such as tables or views). This method allows one to add a new database object.

If the internal database already contains the object, then:

The xml_description defines the table of view's definition, for example:

<table name="mytable">
    <column name="id" pkey="TRUE"/>
    <column name="value"/>
</table>

The partial DTD for this XML description of the object to add is the following (the top node must be a <table> or a <view>):

<!ELEMENT table (column*,check*,fkey*)>
<!ATTLIST table
          name NMTOKEN #REQUIRED>

<!ELEMENT column EMPTY>
<!ATTLIST column
          name NMTOKEN #REQUIRED
          type CDATA #IMPLIED
          pkey (TRUE|FALSE) #IMPLIED
          autoinc (TRUE|FALSE) #IMPLIED
          nullok (TRUE|FALSE) #IMPLIED>

<!ELEMENT check (#PCDATA)>

<!ELEMENT fkey (part+)>
<!ATTLIST fkey
          ref_table NMTOKEN #REQUIRED>

<!ELEMENT part EMPTY>
<!ATTLIST part
          column NMTOKEN #IMPLIED
          ref_column NMTOKEN #IMPLIED>

<!ELEMENT view (definition)>
<!ATTLIST view
          name NMTOKEN #REQUIRED
          descr CDATA #IMPLIED>

<!ELEMENT definition (#PCDATA)>

gda_meta_store_schema_remove_custom_object ()

gboolean
gda_meta_store_schema_remove_custom_object
                               (GdaMetaStore *store,
                                const gchar *obj_name,
                                GError **error);

Removes the custom database object named obj_name .

gda_meta_store_schema_get_all_tables ()

GSList *
gda_meta_store_schema_get_all_tables (GdaMetaStore *store);

Get an ordered list of the tables store knows about. The tables are ordered in a way that tables dependencies are respected: if table B has a foreign key on table A, then table A will be listed before table B in the returned list.

gda_meta_store_schema_get_depend_tables ()

GSList *
gda_meta_store_schema_get_depend_tables
                               (GdaMetaStore *store,
                                const gchar *table_name);

Get an ordered list of the tables store knows about on which the table_name table depends (recursively). The tables are ordered in a way that tables dependencies are respected: if table B has a foreign key on table A, then table A will be listed before table B in the returned list.

gda_meta_store_schema_get_structure ()

GdaMetaStruct *
gda_meta_store_schema_get_structure (GdaMetaStore *store,
                                     GError **error);

Creates a new GdaMetaStruct object representing store 's internal database structure.

gda_meta_store_declare_foreign_key ()

gboolean
gda_meta_store_declare_foreign_key (GdaMetaStore *store,
                                    GdaMetaStruct *mstruct,
                                    const gchar *fk_name,
                                    const gchar *catalog,
                                    const gchar *schema,
                                    const gchar *table,
                                    const gchar *ref_catalog,
                                    const gchar *ref_schema,
                                    const gchar *ref_table,
                                    guint nb_cols,
                                    gchar **colnames,
                                    gchar **ref_colnames,
                                    GError **error);

Defines a new declared foreign key into store . If another declared foreign key is already defined between the two tables and with the same name, then it is first removed.

This method begins a transaction if possible (ie. none is already started), and if it can't, then if there is an error, the job may be partially done.

A check is always performed to make sure all the database objects actually exist and returns an error if not. The check is performed using mstruct if it's not NULL (in this case only the tables already represented in mstruct will be considered, in other words: mstruct will not be modified), and using an internal GdaMetaStruct is NULL.

The catalog , schema , table , ref_catalog , ref_schema and ref_table must follow the SQL identifiers naming convention, see the SQL identifiers section. The same convention needs to be respected for the strings in conames and ref_colnames .

If catalog is not NULL, then schema must also be not NULL (the same restriction applies to ref_catalog and ref_schema ).

Since: 4.2.4

gda_meta_store_undeclare_foreign_key ()

gboolean
gda_meta_store_undeclare_foreign_key (GdaMetaStore *store,
                                      GdaMetaStruct *mstruct,
                                      const gchar *fk_name,
                                      const gchar *catalog,
                                      const gchar *schema,
                                      const gchar *table,
                                      const gchar *ref_catalog,
                                      const gchar *ref_schema,
                                      const gchar *ref_table,
                                      GError **error);

Removes a declared foreign key from store .

This method begins a transaction if possible (ie. none is already started), and if it can't, then if there is an error, the job may be partially done.

A check is always performed to make sure all the database objects actually exist and returns an error if not. The check is performed using mstruct if it's not NULL (in this case only the tables already represented in mstruct will be considered, in other words: mstruct will not be modified), and using an internal GdaMetaStruct is NULL.

See gda_meta_store_declare_foreign_key() for more information anout the catalog , schema , name , ref_catalog , ref_schema and ref_name arguments.

Since: 4.2.4

gda_meta_context_new ()

GdaMetaContext *
gda_meta_context_new (void);

Creates a new GdaMetaContext struct with a GHashTable to store column/value pairs.

Return: (transfer full): a new GdaMetaContext struct with a new created hash to store column name/value pairs.

Since: 5.2

gda_meta_context_copy ()

GdaMetaContext *
gda_meta_context_copy (GdaMetaContext *ctx);

Copy constructor.

Since: 5.2

gda_meta_context_set_table ()

void
gda_meta_context_set_table (GdaMetaContext *ctx,
                            const gchar *table);

Set table's name to use in the context. The table is one of database schema used to store meta information about the database. Use "_tables" to update meta information about database's tables.

Since: 5.2

gda_meta_context_get_table ()

const gchar *
gda_meta_context_get_table (GdaMetaContext *ctx);

Get table's name to used in the context.

Return: (transfer none): A string with the table's name used in the context.

Since: 5.2

gda_meta_context_set_column ()

void
gda_meta_context_set_column (GdaMetaContext *ctx,
                             const gchar *column,
                             const GValue *value,
                             GdaConnection *cnc);

Sets a new column/value pair to the given context ctx . Column, must be a column in the given table's name setted by gda_meta_context_set_table() (a table in the database schema). If the given column already exists it's value is overwrited.

Column's name and value is copied and destroyed when gda_meta_context_free is called.

Since: 5.2

gda_meta_context_set_columns ()

void
gda_meta_context_set_columns (GdaMetaContext *ctx,
                              GHashTable *columns,
                              GdaConnection *cnc);

Set columns to use in the context. The GHashTable use column's name as key and a GValue as value, to represent its value.

columns incements its reference counting. Is recommended to use gda_meta_context_free in order to free them.

Since: 5.2

gda_meta_context_free ()

void
gda_meta_context_free (GdaMetaContext *ctx);

Frees any resources taken by ctx struct. If ctx is NULL, then nothing happens.

Since: 5.2

GDA_META_STORE_ERROR

#define GDA_META_STORE_ERROR gda_meta_store_error_quark ()

enum GdaMetaStoreError

enum GdaMetaStoreChangeType

GdaMetaContext

typedef struct {
	gchar                  *table_name;
	gint                    size;
	gchar                 **column_names;
	GValue                **column_values;
	GHashTable             *columns;/* Added since 5.2 */
} GdaMetaContext;

The GdaMetaContext represents a meta data modification context: the how when used with gda_meta_store_modify_with_context(), and the what when used with gda_connection_update_meta_store().

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.

GdaMetaStoreChange

typedef struct _GdaMetaStoreChange GdaMetaStoreChange;

The “catalog” property

  “catalog”                  gchar *

Catalog in which the database objects will be created.

Flags: Write / Construct Only

Default value: NULL

The “cnc” property

  “cnc”                      GdaConnection *

Connection object internally used.

Flags: Read / Write / Construct Only

The “cnc-string” property

  “cnc-string”               gchar *

Connection string for the internal connection to use.

Flags: Write / Construct Only

Default value: NULL

The “schema” property

  “schema”                   gchar *

Schema in which the database objects will be created.

Flags: Write / Construct Only

Default value: NULL

The “meta-changed” signal

void
user_function (GdaMetaStore *store,
               gpointer      changes,
               gpointer      user_data)

This signal is emitted when the store 's contents have changed (the changes are in the changes list)

Flags: Run First

The “meta-reset” signal

void
user_function (GdaMetaStore *store,
               gpointer      user_data)

This signal is emitted when the store 's contents have been reset completely and when no detailed changes are available

Flags: Run First

The “suggest-update” signal

GError*
user_function (GdaMetaStore *store,
               gpointer      suggest,
               gpointer      user_data)

This signal is emitted when the contents of a table should be updated (data to update or insert only; deleting data is done automatically). This signal is used for internal purposes by the GdaConnection object.

Flags: Run Last