← Back to branch summary

~ubuntu-branches/debian/jessie/sqlheavy/jessie

« back to all changes in this revision

Viewing changes to sqlheavy/sqlheavy-versioned-database.c

  • Committer: Package Import Robot
  • Author(s): Devid Antonio Filoni
  • Date: 2012-05-17 09:47:17 UTC
  • mfrom: (1.1.1)
  • Revision ID: package-import@ubuntu.com-20120517094717-ue17pqaud5tywjj5
Tags: 0.1.1-1
http://bugs.debian.org/663320
* New upstream release (Closes: #663320).
* Fix debug-package-should-be-priority-extra lintian warning.
* debian/control: switch to vala-0.16 in Build-Depends field.
* debian/libsqlheavy-dev.install, debian/libsqlheavygtk-dev.install:
  install files in vala-0.16 dir.
* Update libsqlheavy0.1-0.symbols.amd64 file.
* debian/rules: update override_dh_makeshlibs target.
* Bump Standards-Version to 3.9.3.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sqlheavy/sqlheavy-versioned-database.c
1
 
/* sqlheavy-versioned-database.c generated by valac 0.12.1, the Vala compiler
 
1
/* sqlheavy-versioned-database.c generated by valac 0.16.0, the Vala compiler
2
2
 * generated from sqlheavy-versioned-database.vala, do not modify */
3
3
 
4
4
 
39
39
     */
40
40
SQLHeavyVersionedDatabase* sql_heavy_versioned_database_construct (GType object_type, const gchar* file, const gchar* directory, GError** error) {
41
41
        SQLHeavyVersionedDatabase * self = NULL;
42
 
        gchar* _tmp0_;
 
42
        const gchar* _tmp0_;
43
43
        gchar* _tmp1_;
 
44
        gchar* _tmp2_;
 
45
        const gchar* _tmp3_;
 
46
        const gchar* _tmp5_;
 
47
        const gchar* _tmp6_;
44
48
        g_return_val_if_fail (directory != NULL, NULL);
45
 
        _tmp0_ = g_strdup (file);
46
 
        _tmp1_ = _tmp0_;
47
 
        if (_tmp1_ == NULL) {
48
 
                gchar* _tmp2_;
49
 
                _tmp2_ = g_strdup (":memory:");
50
 
                _g_free0 (_tmp1_);
51
 
                _tmp1_ = _tmp2_;
 
49
        _tmp0_ = file;
 
50
        _tmp1_ = g_strdup (_tmp0_);
 
51
        _tmp2_ = _tmp1_;
 
52
        _tmp3_ = _tmp2_;
 
53
        if (_tmp3_ == NULL) {
 
54
                gchar* _tmp4_;
 
55
                _tmp4_ = g_strdup (":memory:");
 
56
                _g_free0 (_tmp2_);
 
57
                _tmp2_ = _tmp4_;
52
58
        }
53
 
        self = (SQLHeavyVersionedDatabase*) g_object_new (object_type, "filename", _tmp1_, "schema", directory, NULL);
54
 
        _g_free0 (_tmp1_);
 
59
        _tmp5_ = _tmp2_;
 
60
        _tmp6_ = directory;
 
61
        self = (SQLHeavyVersionedDatabase*) g_object_new (object_type, "filename", _tmp5_, "schema", _tmp6_, NULL);
 
62
        _g_free0 (_tmp2_);
55
63
        return self;
56
64
}
57
65
 
63
71
 
64
72
const gchar* sql_heavy_versioned_database_get_schema (SQLHeavyVersionedDatabase* self) {
65
73
        const gchar* result;
 
74
        const gchar* _tmp0_;
66
75
        g_return_val_if_fail (self != NULL, NULL);
67
 
        result = self->priv->_schema;
 
76
        _tmp0_ = self->priv->_schema;
 
77
        result = _tmp0_;
68
78
        return result;
69
79
}
70
80
 
71
81
 
72
82
static void sql_heavy_versioned_database_set_schema (SQLHeavyVersionedDatabase* self, const gchar* value) {
73
 
        gchar* _tmp0_;
 
83
        const gchar* _tmp0_;
 
84
        gchar* _tmp1_;
74
85
        g_return_if_fail (self != NULL);
75
 
        _tmp0_ = g_strdup (value);
 
86
        _tmp0_ = value;
 
87
        _tmp1_ = g_strdup (_tmp0_);
76
88
        _g_free0 (self->priv->_schema);
77
 
        self->priv->_schema = _tmp0_;
 
89
        self->priv->_schema = _tmp1_;
78
90
        g_object_notify ((GObject *) self, "schema");
79
91
}
80
92
 
83
95
        GObject * obj;
84
96
        GObjectClass * parent_class;
85
97
        SQLHeavyVersionedDatabase * self;
86
 
        gint _tmp0_;
 
98
        gint _tmp2_;
 
99
        gint _tmp3_;
87
100
        gint version;
88
101
        gchar* script_name = NULL;
89
 
        SQLHeavyTransaction* trans;
 
102
        gint _tmp4_;
90
103
        GError * _inner_error_ = NULL;
91
104
        parent_class = G_OBJECT_CLASS (sql_heavy_versioned_database_parent_class);
92
105
        obj = parent_class->constructor (type, n_construct_properties, construct_properties);
93
106
        self = SQL_HEAVY_VERSIONED_DATABASE (obj);
94
 
        sql_heavy_database_init ((SQLHeavyDatabase*) self, NULL, &_inner_error_);
95
 
        if (_inner_error_ != NULL) {
96
 
                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
97
 
                        goto __catch50_sql_heavy_error;
 
107
        {
 
108
                sql_heavy_database_init ((SQLHeavyDatabase*) self, NULL, &_inner_error_);
 
109
                if (_inner_error_ != NULL) {
 
110
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
111
                                goto __catch50_sql_heavy_error;
 
112
                        }
 
113
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
114
                        g_clear_error (&_inner_error_);
98
115
                }
99
 
                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
100
 
                g_clear_error (&_inner_error_);
101
116
        }
102
117
        goto __finally50;
103
118
        __catch50_sql_heavy_error:
104
119
        {
105
 
                GError * err;
 
120
                GError* err = NULL;
 
121
                GError* _tmp0_;
 
122
                const gchar* _tmp1_;
106
123
                err = _inner_error_;
107
124
                _inner_error_ = NULL;
 
125
                _tmp0_ = err;
 
126
                _tmp1_ = _tmp0_->message;
108
127
                g_critical ("sqlheavy-versioned-database.vala:27: Unable to initialize versioned da" \
109
 
"tabase: %s", err->message);
 
128
"tabase: %s", _tmp1_);
110
129
                _g_error_free0 (err);
111
130
        }
112
131
        __finally50:
114
133
                g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
115
134
                g_clear_error (&_inner_error_);
116
135
        }
117
 
        _tmp0_ = sql_heavy_database_get_user_version ((SQLHeavyDatabase*) self);
118
 
        version = _tmp0_;
119
 
        if (version == 0) {
120
 
                gchar* _tmp1_ = NULL;
121
 
                gint _tmp2_;
122
 
                _tmp1_ = g_build_filename (self->priv->_schema, "Create.sql", NULL);
 
136
        _tmp2_ = sql_heavy_database_get_user_version ((SQLHeavyDatabase*) self);
 
137
        _tmp3_ = _tmp2_;
 
138
        version = _tmp3_;
 
139
        _tmp4_ = version;
 
140
        if (_tmp4_ == 0) {
 
141
                const gchar* _tmp5_;
 
142
                gchar* _tmp6_ = NULL;
 
143
                gint _tmp13_;
 
144
                gint _tmp14_;
 
145
                gint _tmp15_;
 
146
                _tmp5_ = self->priv->_schema;
 
147
                _tmp6_ = g_build_filename (_tmp5_, "Create.sql", NULL);
123
148
                _g_free0 (script_name);
124
 
                script_name = _tmp1_;
125
 
                sql_heavy_queryable_run_script ((SQLHeavyQueryable*) self, script_name, &_inner_error_);
126
 
                if (_inner_error_ != NULL) {
127
 
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
128
 
                                goto __catch51_sql_heavy_error;
 
149
                script_name = _tmp6_;
 
150
                {
 
151
                        const gchar* _tmp7_;
 
152
                        _tmp7_ = script_name;
 
153
                        sql_heavy_queryable_run_script ((SQLHeavyQueryable*) self, _tmp7_, &_inner_error_);
 
154
                        if (_inner_error_ != NULL) {
 
155
                                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
156
                                        goto __catch51_sql_heavy_error;
 
157
                                }
 
158
                                _g_free0 (script_name);
 
159
                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
160
                                g_clear_error (&_inner_error_);
129
161
                        }
130
 
                        _g_free0 (script_name);
131
 
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
132
 
                        g_clear_error (&_inner_error_);
133
162
                }
134
163
                goto __finally51;
135
164
                __catch51_sql_heavy_error:
136
165
                {
137
 
                        GError * e;
 
166
                        GError* e = NULL;
 
167
                        const gchar* _tmp8_;
 
168
                        GError* _tmp9_;
 
169
                        const gchar* _tmp10_;
 
170
                        GError* _tmp11_;
 
171
                        gint _tmp12_;
138
172
                        e = _inner_error_;
139
173
                        _inner_error_ = NULL;
 
174
                        _tmp8_ = script_name;
 
175
                        _tmp9_ = e;
 
176
                        _tmp10_ = _tmp9_->message;
 
177
                        _tmp11_ = e;
 
178
                        _tmp12_ = _tmp11_->code;
140
179
                        g_critical ("sqlheavy-versioned-database.vala:39: Unable to run creation script `%s" \
141
 
"' (%s: %d).", script_name, e->message, e->code);
 
180
"' (%s: %d).", _tmp8_, _tmp10_, _tmp12_);
142
181
                        _g_error_free0 (e);
143
182
                }
144
183
                __finally51:
147
186
                        g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
148
187
                        g_clear_error (&_inner_error_);
149
188
                }
150
 
                _tmp2_ = sql_heavy_database_get_user_version ((SQLHeavyDatabase*) self);
151
 
                version = _tmp2_;
152
 
                if (version == 0) {
 
189
                _tmp13_ = sql_heavy_database_get_user_version ((SQLHeavyDatabase*) self);
 
190
                _tmp14_ = _tmp13_;
 
191
                version = _tmp14_;
 
192
                _tmp15_ = version;
 
193
                if (_tmp15_ == 0) {
 
194
                        gint _tmp16_;
153
195
                        version = 1;
154
 
                        sql_heavy_database_set_user_version ((SQLHeavyDatabase*) self, version);
155
 
                }
156
 
        }
157
 
        trans = NULL;
158
 
        while (TRUE) {
159
 
                gchar* _tmp3_ = NULL;
160
 
                gchar* _tmp4_;
161
 
                gchar* _tmp5_ = NULL;
162
 
                gboolean _tmp6_;
163
 
                _tmp3_ = g_strdup_printf ("Update-to-%d.sql", version + 1);
164
 
                _tmp4_ = _tmp3_;
165
 
                _tmp5_ = g_build_filename (self->priv->_schema, _tmp4_, NULL);
166
 
                _g_free0 (script_name);
167
 
                script_name = _tmp5_;
168
 
                _g_free0 (_tmp4_);
169
 
                _tmp6_ = g_file_test (script_name, G_FILE_TEST_EXISTS);
170
 
                if (!_tmp6_) {
171
 
                        break;
172
 
                }
173
 
                if (trans == NULL) {
174
 
                        SQLHeavyTransaction* _tmp7_ = NULL;
175
 
                        SQLHeavyTransaction* _tmp8_;
176
 
                        _tmp7_ = sql_heavy_queryable_begin_transaction ((SQLHeavyQueryable*) self, &_inner_error_);
177
 
                        _tmp8_ = _tmp7_;
178
 
                        if (_inner_error_ != NULL) {
179
 
                                _g_object_unref0 (trans);
180
 
                                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
181
 
                                        goto __catch52_sql_heavy_error;
182
 
                                }
183
 
                                _g_object_unref0 (trans);
184
 
                                _g_free0 (script_name);
185
 
                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
186
 
                                g_clear_error (&_inner_error_);
187
 
                        }
188
 
                        _g_object_unref0 (trans);
189
 
                        trans = _tmp8_;
190
 
                }
191
 
                sql_heavy_queryable_run_script ((SQLHeavyQueryable*) trans, script_name, &_inner_error_);
192
 
                if (_inner_error_ != NULL) {
193
 
                        _g_object_unref0 (trans);
194
 
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
195
 
                                goto __catch52_sql_heavy_error;
196
 
                        }
197
 
                        _g_object_unref0 (trans);
198
 
                        _g_free0 (script_name);
199
 
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
200
 
                        g_clear_error (&_inner_error_);
201
 
                }
202
 
                version = version + 1;
203
 
                sql_heavy_database_set_user_version ((SQLHeavyDatabase*) self, version);
204
 
        }
205
 
        if (trans != NULL) {
206
 
                sql_heavy_transaction_commit (trans, &_inner_error_);
207
 
                if (_inner_error_ != NULL) {
208
 
                        _g_object_unref0 (trans);
209
 
                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
210
 
                                goto __catch52_sql_heavy_error;
211
 
                        }
212
 
                        _g_object_unref0 (trans);
213
 
                        _g_free0 (script_name);
214
 
                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
215
 
                        g_clear_error (&_inner_error_);
216
 
                }
217
 
        }
218
 
        _g_object_unref0 (trans);
 
196
                        _tmp16_ = version;
 
197
                        sql_heavy_database_set_user_version ((SQLHeavyDatabase*) self, _tmp16_);
 
198
                }
 
199
        }
 
200
        {
 
201
                SQLHeavyTransaction* trans;
 
202
                SQLHeavyTransaction* _tmp31_;
 
203
                trans = NULL;
 
204
                while (TRUE) {
 
205
                        const gchar* _tmp17_;
 
206
                        gint _tmp18_;
 
207
                        gchar* _tmp19_ = NULL;
 
208
                        gchar* _tmp20_;
 
209
                        gchar* _tmp21_ = NULL;
 
210
                        const gchar* _tmp22_;
 
211
                        gboolean _tmp23_ = FALSE;
 
212
                        SQLHeavyTransaction* _tmp24_;
 
213
                        SQLHeavyTransaction* _tmp27_;
 
214
                        const gchar* _tmp28_;
 
215
                        gint _tmp29_;
 
216
                        gint _tmp30_;
 
217
                        _tmp17_ = self->priv->_schema;
 
218
                        _tmp18_ = version;
 
219
                        _tmp19_ = g_strdup_printf ("Update-to-%d.sql", _tmp18_ + 1);
 
220
                        _tmp20_ = _tmp19_;
 
221
                        _tmp21_ = g_build_filename (_tmp17_, _tmp20_, NULL);
 
222
                        _g_free0 (script_name);
 
223
                        script_name = _tmp21_;
 
224
                        _g_free0 (_tmp20_);
 
225
                        _tmp22_ = script_name;
 
226
                        _tmp23_ = g_file_test (_tmp22_, G_FILE_TEST_EXISTS);
 
227
                        if (!_tmp23_) {
 
228
                                break;
 
229
                        }
 
230
                        _tmp24_ = trans;
 
231
                        if (_tmp24_ == NULL) {
 
232
                                SQLHeavyTransaction* _tmp25_ = NULL;
 
233
                                SQLHeavyTransaction* _tmp26_;
 
234
                                _tmp25_ = sql_heavy_queryable_begin_transaction ((SQLHeavyQueryable*) self, &_inner_error_);
 
235
                                _tmp26_ = _tmp25_;
 
236
                                if (_inner_error_ != NULL) {
 
237
                                        _g_object_unref0 (trans);
 
238
                                        if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
239
                                                goto __catch52_sql_heavy_error;
 
240
                                        }
 
241
                                        _g_object_unref0 (trans);
 
242
                                        _g_free0 (script_name);
 
243
                                        g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
244
                                        g_clear_error (&_inner_error_);
 
245
                                }
 
246
                                _g_object_unref0 (trans);
 
247
                                trans = _tmp26_;
 
248
                        }
 
249
                        _tmp27_ = trans;
 
250
                        _tmp28_ = script_name;
 
251
                        sql_heavy_queryable_run_script ((SQLHeavyQueryable*) _tmp27_, _tmp28_, &_inner_error_);
 
252
                        if (_inner_error_ != NULL) {
 
253
                                _g_object_unref0 (trans);
 
254
                                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
255
                                        goto __catch52_sql_heavy_error;
 
256
                                }
 
257
                                _g_object_unref0 (trans);
 
258
                                _g_free0 (script_name);
 
259
                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
260
                                g_clear_error (&_inner_error_);
 
261
                        }
 
262
                        _tmp29_ = version;
 
263
                        version = _tmp29_ + 1;
 
264
                        _tmp30_ = version;
 
265
                        sql_heavy_database_set_user_version ((SQLHeavyDatabase*) self, _tmp30_);
 
266
                }
 
267
                _tmp31_ = trans;
 
268
                if (_tmp31_ != NULL) {
 
269
                        SQLHeavyTransaction* _tmp32_;
 
270
                        _tmp32_ = trans;
 
271
                        sql_heavy_transaction_commit (_tmp32_, &_inner_error_);
 
272
                        if (_inner_error_ != NULL) {
 
273
                                _g_object_unref0 (trans);
 
274
                                if (_inner_error_->domain == SQL_HEAVY_ERROR) {
 
275
                                        goto __catch52_sql_heavy_error;
 
276
                                }
 
277
                                _g_object_unref0 (trans);
 
278
                                _g_free0 (script_name);
 
279
                                g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
 
280
                                g_clear_error (&_inner_error_);
 
281
                        }
 
282
                }
 
283
                _g_object_unref0 (trans);
 
284
        }
219
285
        goto __finally52;
220
286
        __catch52_sql_heavy_error:
221
287
        {
222
 
                GError * e;
 
288
                GError* e = NULL;
 
289
                const gchar* _tmp33_;
 
290
                GError* _tmp34_;
 
291
                const gchar* _tmp35_;
 
292
                GError* _tmp36_;
 
293
                gint _tmp37_;
223
294
                e = _inner_error_;
224
295
                _inner_error_ = NULL;
 
296
                _tmp33_ = script_name;
 
297
                _tmp34_ = e;
 
298
                _tmp35_ = _tmp34_->message;
 
299
                _tmp36_ = e;
 
300
                _tmp37_ = _tmp36_->code;
225
301
                g_critical ("sqlheavy-versioned-database.vala:65: Unable to run update script `%s' " \
226
 
"(%s: %d).", script_name, e->message, e->code);
 
302
"(%s: %d).", _tmp33_, _tmp35_, _tmp37_);
227
303
                _g_error_free0 (e);
228
304
        }
229
305
        __finally52: