gda_value_new ()

GValue *
gda_value_new (GType type);

Makes a new GValue of type type .

[skip]

GDA_VALUE_HOLDS_NULL()

#define GDA_VALUE_HOLDS_NULL(value)            G_VALUE_HOLDS(value, GDA_TYPE_NULL)

GDA_VALUE_HOLDS_DEFAULT()

#define GDA_VALUE_HOLDS_DEFAULT(value)         G_VALUE_HOLDS(value, GDA_TYPE_DEFAULT)

GDA_VALUE_HOLDS_BINARY()

#define GDA_VALUE_HOLDS_BINARY(value)          G_VALUE_HOLDS(value, GDA_TYPE_BINARY)

GDA_VALUE_HOLDS_BLOB()

#define GDA_VALUE_HOLDS_BLOB(value)            G_VALUE_HOLDS(value, GDA_TYPE_BLOB)

GDA_VALUE_HOLDS_GEOMETRIC_POINT()

#define GDA_VALUE_HOLDS_GEOMETRIC_POINT(value) G_VALUE_HOLDS(value, GDA_TYPE_GEOMETRIC_POINT)

GDA_VALUE_HOLDS_NUMERIC()

#define GDA_VALUE_HOLDS_NUMERIC(value)         G_VALUE_HOLDS(value, GDA_TYPE_NUMERIC)

GDA_VALUE_HOLDS_SHORT()

#define GDA_VALUE_HOLDS_SHORT(value)           G_VALUE_HOLDS(value, GDA_TYPE_SHORT)

GDA_VALUE_HOLDS_USHORT()

#define GDA_VALUE_HOLDS_USHORT(value)          G_VALUE_HOLDS(value, GDA_TYPE_USHORT)

GDA_VALUE_HOLDS_TIME()

#define GDA_VALUE_HOLDS_TIME(value)            G_VALUE_HOLDS(value, GDA_TYPE_TIME)

GDA_VALUE_HOLDS_TIMESTAMP()

#define GDA_VALUE_HOLDS_TIMESTAMP(value)       G_VALUE_HOLDS(value, GDA_TYPE_TIMESTAMP)

gda_value_new_null ()

GValue *
gda_value_new_null (void);

Creates a new GValue initiated to a GdaNull structure with a GDA_TYPE_NULL, to represent a NULL in the database.

[skip]

gda_value_set_null ()

void
gda_value_set_null (GValue *value);

Sets the type of value to GDA_TYPE_NULL.

[skip]

gda_value_new_default ()

GValue *
gda_value_new_default (const gchar *default_val);

Creates a new default value.

[skip]

Since: 4.2.9

gda_value_copy ()

GValue *
gda_value_copy (const GValue *value);

Creates a new GValue from an existing one.

[skip]

gda_value_free ()

void
gda_value_free (GValue *value);

Deallocates all memory associated to a GValue.

[skip]

gda_value_new_from_string ()

GValue *
gda_value_new_from_string (const gchar *as_string,
                           GType type);

Makes a new GValue of type type from its string representation.

For more information about the string format, see the gda_value_set_from_string() function. This function is typically used when reading configuration files or other non-user input that should be locale independent.

[skip]

gda_value_set_from_string ()

gboolean
gda_value_set_from_string (GValue *value,
                           const gchar *as_string,
                           GType type);

Stores the value data from its string representation as type .

The accepted formats are:

This function is typically used when reading configuration files or other non-user input that should be locale independent.

[skip]

gda_value_set_from_value ()

gboolean
gda_value_set_from_value (GValue *value,
                          const GValue *from);

Sets the value of a GValue from another GValue. This is different from gda_value_copy, which creates a new GValue. gda_value_set_from_value, on the other hand, copies the contents of copy into value , which must already be allocated.

If values are incompatible (see g_value_type_compatible ) then value is set to a GDA_TYPE_NULL, and FALSE is returned.

[skip]

gda_value_stringify ()

gchar *
gda_value_stringify (const GValue *value);

Converts a GValue to its string representation which is a human readable value. Note that the returned string does not take into account the current locale of the user (on the contrary to the GdaDataHandler objects). Using this function should be limited to debugging and values serialization purposes.

Output is in the "C" locale for numbers, and dates are converted in a YYYY-MM-DD format.

gda_value_differ ()

gint
gda_value_differ (const GValue *value1,
                  const GValue *value2);

Tells if two values are equal or not, by comparing memory representations. Unlike gda_value_compare(), the returned value is boolean, and gives no idea about ordering.

The two values must be of the same type, with the exception that a value of any type can be compared to a GDA_TYPE_NULL value, specifically:

gda_value_compare ()

gint
gda_value_compare (const GValue *value1,
                   const GValue *value2);

Compares two values of the same type, with the exception that a value of any type can be compared to a GDA_TYPE_NULL value, specifically:

gda_value_new_from_xml ()

GValue *
gda_value_new_from_xml (const xmlNodePtr node);

Creates a GValue from an XML representation of it. That XML node corresponds to the following string representation: <value type="gdatype">value</value>

For more information about the string format, see the gda_value_set_from_string() function. This function is typically used when reading configuration files or other non-user input that should be locale independent.

[skip]

gda_value_to_xml ()

xmlNodePtr
gda_value_to_xml (const GValue *value);

Serializes the given GValue to an XML node string.

[skip]

gda_value_reset_with_type ()

void
gda_value_reset_with_type (GValue *value,
                           GType type);

Resets the GValue and set a new type to GType.

[skip]

gda_value_is_null ()

gboolean
gda_value_is_null (const GValue *value);

Tests if a given value is of type GDA_TYPE_NULL.

[skip]

gda_value_is_number ()

gboolean
gda_value_is_number (const GValue *value);

Gets whether the value stored in the given GValue is of numeric type or not.

[skip]

gda_value_isa()

#define gda_value_isa(value, type) (G_VALUE_HOLDS(value, type))

gda_value_new_binary ()

GValue *
gda_value_new_binary (const guchar *val,
                      glong size);

Makes a new GValue of type GDA_TYPE_BINARY with value val .

[skip]

gda_value_get_binary ()

const GdaBinary *
gda_value_get_binary (const GValue *value);

[skip]

gda_value_set_binary ()

void
gda_value_set_binary (GValue *value,
                      const GdaBinary *binary);

Stores val into value .

[skip]

gda_value_take_binary ()

void
gda_value_take_binary (GValue *value,
                       GdaBinary *binary);

Stores val into value , but on the contrary to gda_value_set_binary(), the binary argument is not copied, but used as-is and it should be considered owned by value .

[skip]

gda_binary_copy ()

gpointer
gda_binary_copy (gpointer boxed);

Creates a new GdaBinary structure from an existing one.

gda_binary_free ()

void
gda_binary_free (gpointer boxed);

Deallocates all memory associated to the given GdaBinary.

gda_binary_to_string ()

gchar *
gda_binary_to_string (const GdaBinary *bin,
                      guint maxlen);

Converts all the non printable characters of bin->data into the "\xyz" representation where "xyz" is the octal representation of the byte, and the '\' (backslash) character is converted to "\". Printable characters (defined by g_ascii_isprint()) as well as newline character are not converted.

Note that the backslash and newline characters are considered as printable characters and will not be represented by the "\xyz" representation.

Use this function to get a representation as much readable by humans as possible of a binary chunk. Note that this function is internally called when transforming a binary value to a string for example when using g_value_transform() or gda_value_stringify().

gda_string_to_binary ()

GdaBinary *
gda_string_to_binary (const gchar *str);

Performs the reverse of gda_binary_to_string() (note that for any "\xyz" succession of 4 characters where "xyz" represents a valid octal value, the resulting read value will be modulo 256).

I str is NULL, then an empty (i.e. where the data part is NULL) GdaBinary is created and returned.

gda_value_new_blob ()

GValue *
gda_value_new_blob (const guchar *val,
                    glong size);

Makes a new GValue of type GDA_TYPE_BLOB with the data contained by val .

[skip]

gda_value_new_blob_from_file ()

GValue *
gda_value_new_blob_from_file (const gchar *filename);

Makes a new GValue of type GDA_TYPE_BLOB interfacing with the contents of the file named filename

[skip]

gda_blob_copy ()

gpointer
gda_blob_copy (gpointer boxed);

Creates a new GdaBlob structure from an existing one.

gda_blob_free ()

void
gda_blob_free (gpointer boxed);

Deallocates all memory associated to the given GdaBlob.

gda_value_get_blob ()

const GdaBlob *
gda_value_get_blob (const GValue *value);

[skip]

gda_value_set_blob ()

void
gda_value_set_blob (GValue *value,
                    const GdaBlob *blob);

Stores val into value .

[skip]

gda_value_take_blob ()

void
gda_value_take_blob (GValue *value,
                     GdaBlob *blob);

Stores val into value , but on the contrary to gda_value_set_blob(), the blob argument is not copied, but used as-is and it should be considered owned by value .

[skip]

gda_blob_set_op ()

void
gda_blob_set_op (GdaBlob *blob,
                 GdaBlobOp *op);

correctly assigns op to blob

gda_blob_to_string ()

gchar *
gda_blob_to_string (GdaBlob *blob,
                    guint maxlen);

Converts all the non printable characters of blob->data into the \xxx representation where xxx is the octal representation of the byte, and the '\' (backslash) character is converted to "\".

gda_geometricpoint_copy ()

gpointer
gda_geometricpoint_copy (gpointer boxed);

gda_geometricpoint_free ()

void
gda_geometricpoint_free (gpointer boxed);

gda_value_get_geometric_point ()

const GdaGeometricPoint *
gda_value_get_geometric_point (const GValue *value);

[skip]

gda_value_set_geometric_point ()

void
gda_value_set_geometric_point (GValue *value,
                               const GdaGeometricPoint *val);

Stores val into value .

[skip]

gda_numeric_new ()

GdaNumeric *
gda_numeric_new (void);

Creates a new GdaNumeric with defaults.

Since: 5.0.2

gda_numeric_copy ()

GdaNumeric *
gda_numeric_copy (GdaNumeric *src);

Creates a new GdaNumeric structure from an existing one.

gda_numeric_free ()

void
gda_numeric_free (GdaNumeric *numeric);

Deallocates all memory associated to the given boxed

gda_numeric_get_string ()

gchar *
gda_numeric_get_string (const GdaNumeric *numeric);

Get the string representation of numeric , in the C locale format (dot as a fraction separator).

Since: 5.0.2

gda_numeric_get_double ()

gdouble
gda_numeric_get_double (const GdaNumeric *numeric);

Since: 5.0.2

gda_numeric_get_precision ()

glong
gda_numeric_get_precision (const GdaNumeric *numeric);

Gets the precision of a GdaNumeric.

Since: 5.0.2

gda_numeric_get_width ()

glong
gda_numeric_get_width (const GdaNumeric *numeric);

Gets the width of a GdaNumeric. (Not yet implemented).

Since: 5.0.2

gda_numeric_set_double ()

void
gda_numeric_set_double (GdaNumeric *numeric,
                        gdouble number);

Sets numeric using a gdouble represented by number .

Since: 5.0.2

gda_numeric_set_from_string ()

void
gda_numeric_set_from_string (GdaNumeric *numeric,
                             const gchar *str);

Sets numeric with a number represented by str , in the C locale format (dot as a fraction separator).

Since: 5.0.2

gda_numeric_set_precision ()

void
gda_numeric_set_precision (GdaNumeric *numeric,
                           glong precision);

Sets the precision of a GdaNumeric.

Since: 5.0.2

gda_numeric_set_width ()

void
gda_numeric_set_width (GdaNumeric *numeric,
                       glong width);

Sets the width of a GdaNumeric. (Not yet implemented).

Since: 5.0.2

gda_value_get_numeric ()

const GdaNumeric *
gda_value_get_numeric (const GValue *value);

[skip]

gda_value_set_numeric ()

void
gda_value_set_numeric (GValue *value,
                       const GdaNumeric *val);

Stores val into value .

[skip]

gda_time_copy ()

gpointer
gda_time_copy (gpointer boxed);

gda_time_free ()

void
gda_time_free (gpointer boxed);

gda_time_valid ()

gboolean
gda_time_valid (const GdaTime *time);

Since: 4.2

gda_time_change_timezone ()

void
gda_time_change_timezone (GdaTime *time,
                          glong ntz);

Changes time 's timezone (for example to convert from GMT to another time zone). If time 's current timezone is unset (i.e. equal to GDA_TIMEZONE_INVALID), then this function simply sets time 's timezone attribute; Otherwise, it adds or removes hours, minutes or seconds to reflect the time in the new timezone.

Note: the resulting will always be a valid time.

Since: 5.2

gda_value_get_time ()

const GdaTime *
gda_value_get_time (const GValue *value);

[skip]

gda_value_set_time ()

void
gda_value_set_time (GValue *value,
                    const GdaTime *val);

Stores val into value .

[skip]

gda_timestamp_copy ()

gpointer
gda_timestamp_copy (gpointer boxed);

gda_timestamp_free ()

void
gda_timestamp_free (gpointer boxed);

gda_timestamp_valid ()

gboolean
gda_timestamp_valid (const GdaTimestamp *timestamp);

Since: 4.2

gda_timestamp_change_timezone ()

void
gda_timestamp_change_timezone (GdaTimestamp *ts,
                               glong ntz);

This function is similar to gda_time_change_timezone() but operates on time stamps.

Note: the resulting will always be a valid time.

Since: 5.2

gda_value_get_timestamp ()

const GdaTimestamp *
gda_value_get_timestamp (const GValue *value);

[skip]

gda_value_set_timestamp ()

void
gda_value_set_timestamp (GValue *value,
                         const GdaTimestamp *val);

Stores val into value .

[skip]

gda_value_new_timestamp_from_timet ()

GValue *
gda_value_new_timestamp_from_timet (time_t val);

Makes a new GValue of type GDA_TYPE_TIMESTAMP with value val (of type time_t). The returned timestamp's value is relative to the current timezone (i.e. is localtime).

For example, to get a time stamp representing the current date and time, use:

[skip]

gda_value_get_short ()

gshort
gda_value_get_short (const GValue *value);

[skip]

gda_value_set_short ()

void
gda_value_set_short (GValue *value,
                     const gshort val);

Stores val into value .

[skip]

gda_value_get_ushort ()

gushort
gda_value_get_ushort (const GValue *value);

[skip]

gda_value_set_ushort ()

void
gda_value_set_ushort (GValue *value,
                      const gushort val);

Stores val into value .

[skip]

enum GdaValueAttribute

GDA_TYPE_NULL

#define GDA_TYPE_NULL (gda_null_get_type())

GDA_TYPE_DEFAULT

#define GDA_TYPE_DEFAULT (gda_default_get_type())

GDA_TYPE_BINARY

#define GDA_TYPE_BINARY (gda_binary_get_type())

GDA_TYPE_BLOB

#define GDA_TYPE_BLOB (gda_blob_get_type())

GDA_TYPE_GEOMETRIC_POINT

#define GDA_TYPE_GEOMETRIC_POINT (gda_geometricpoint_get_type())

GDA_TYPE_NUMERIC

#define GDA_TYPE_NUMERIC (gda_numeric_get_type())

GDA_TYPE_SHORT

#define GDA_TYPE_SHORT (gda_short_get_type())

GDA_TYPE_USHORT

#define GDA_TYPE_USHORT (gda_ushort_get_type())

GDA_TYPE_TIME

#define GDA_TYPE_TIME (gda_time_get_type())

GDA_TYPE_TIMESTAMP

#define GDA_TYPE_TIMESTAMP (gda_timestamp_get_type())

GdaBinary

typedef struct {
	guchar *data;
	glong   binary_length;
} GdaBinary;

GdaBlob

typedef struct {
	GdaBinary  data;
	GdaBlobOp *op;
} GdaBlob;

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_set_op().

GdaGeometricPoint

typedef struct {
	gdouble x;
	gdouble y;
} GdaGeometricPoint;

struct GdaNumeric

struct GdaNumeric {
	gchar*   GSEAL(number);
	glong    GSEAL(precision);
	glong    GSEAL(width);
};

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.

GdaTime

typedef struct {
	gushort hour;
	gushort minute;
	gushort second;
	gulong  fraction;
	glong   timezone;
} GdaTime;

Represents a time information.

GdaTimestamp

typedef struct {
	gshort  year;
	gushort month;
	gushort day;
	gushort hour;
	gushort minute;
	gushort second;
	gulong  fraction;
	glong   timezone;
} GdaTimestamp;

Represents an instant (a time stamp)