rubyfb 0.5.5 → 0.5.6

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/ext/ResultSet.c CHANGED
@@ -3,20 +3,20 @@
3
3
  *----------------------------------------------------------------------------*/
4
4
  /**
5
5
  * Copyright � Peter Wood, 2005
6
- *
6
+ *
7
7
  * The contents of this file are subject to the Mozilla Public License Version
8
8
  * 1.1 (the "License"); you may not use this file except in compliance with the
9
- * License. You may obtain a copy of the License at
9
+ * License. You may obtain a copy of the License at
10
10
  *
11
11
  * http://www.mozilla.org/MPL/
12
- *
12
+ *
13
13
  * Software distributed under the License is distributed on an "AS IS" basis,
14
14
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
15
15
  * the specificlanguage governing rights and limitations under the License.
16
- *
16
+ *
17
17
  * The Original Code is the FireRuby extension for the Ruby language.
18
- *
19
- * The Initial Developer of the Original Code is Peter Wood. All Rights
18
+ *
19
+ * The Initial Developer of the Original Code is Peter Wood. All Rights
20
20
  * Reserved.
21
21
  *
22
22
  * @author Peter Wood
@@ -47,6 +47,7 @@ static VALUE getResultSetDialect(VALUE);
47
47
  static VALUE getResultSetColumnCount(VALUE);
48
48
  static VALUE getResultSetColumnName(VALUE, VALUE);
49
49
  static VALUE getResultSetColumnAlias(VALUE, VALUE);
50
+ static VALUE getResultSetColumnScale(VALUE, VALUE);
50
51
  static VALUE getResultSetColumnTable(VALUE, VALUE);
51
52
  static VALUE getResultSetColumnType(VALUE, VALUE);
52
53
  static VALUE eachResultSetRow(VALUE);
@@ -67,24 +68,22 @@ VALUE cResultSet;
67
68
  * @return A reference to the newly allocated ResultSet object.
68
69
  *
69
70
  */
70
- VALUE allocateResultSet(VALUE klass)
71
- {
72
- ResultsHandle *results = ALLOC(ResultsHandle);
73
-
74
- if(results == NULL)
75
- {
76
- rb_raise(rb_eNoMemError,
77
- "Memory allocation failure allocating a result set.");
78
- }
79
- results->handle = 0;
80
- results->output = NULL;
81
- results->exhausted = 0;
82
- results->fetched = 0;
83
- results->dialect = 0;
84
- results->procedure_output_fetch_state = -1;
85
- results->transaction = Qnil;
86
-
87
- return(Data_Wrap_Struct(klass, resultSetMark, resultSetFree, results));
71
+ VALUE allocateResultSet(VALUE klass) {
72
+ ResultsHandle *results = ALLOC(ResultsHandle);
73
+
74
+ if(results == NULL) {
75
+ rb_raise(rb_eNoMemError,
76
+ "Memory allocation failure allocating a result set.");
77
+ }
78
+ results->handle = 0;
79
+ results->output = NULL;
80
+ results->exhausted = 0;
81
+ results->fetched = 0;
82
+ results->dialect = 0;
83
+ results->procedure_output_fetch_state = -1;
84
+ results->transaction = Qnil;
85
+
86
+ return(Data_Wrap_Struct(klass, resultSetMark, resultSetFree, results));
88
87
  }
89
88
 
90
89
 
@@ -107,140 +106,122 @@ VALUE allocateResultSet(VALUE klass)
107
106
  *
108
107
  */
109
108
  VALUE initializeResultSet(VALUE self, VALUE connection, VALUE transaction,
110
- VALUE sql, VALUE dialect, VALUE parameters)
111
- {
112
- short setting = 0;
113
- int type = 0,
114
- inputs = 0,
115
- outputs = 0;
116
- long affected = 0;
117
- ResultsHandle *results = NULL;
118
- VALUE value = Qnil;
119
- ConnectionHandle *cHandle = NULL;
120
- TransactionHandle *tHandle = NULL;
121
- XSQLDA *params = NULL;
122
-
123
- /* Validate the inputs. */
124
- if(TYPE(connection) == T_DATA &&
125
- RDATA(connection)->dfree == (RUBY_DATA_FUNC)connectionFree)
126
- {
127
- if(rb_funcall(connection, rb_intern("open?"), 0) == Qfalse)
128
- {
129
- rb_fireruby_raise(NULL, "Closed connection specified for result set.");
130
- }
131
- }
132
- else
133
- {
134
- rb_fireruby_raise(NULL, "Invalid connection specified for result set.");
135
- }
136
-
137
- if(TYPE(transaction) == T_DATA &&
138
- RDATA(transaction)->dfree == (RUBY_DATA_FUNC)transactionFree)
139
- {
140
- if(rb_funcall(transaction, rb_intern("active?"), 0) == Qfalse)
141
- {
142
- rb_fireruby_raise(NULL, "Inactive transaction specified for result set.");
143
- }
144
- }
145
- else
146
- {
147
- rb_fireruby_raise(NULL, "Invalid transaction specified for result set.");
148
- }
149
-
150
- value = rb_funcall(dialect, rb_intern("to_i"), 0);
151
- if(TYPE(value) == T_FIXNUM)
152
- {
153
- setting = FIX2INT(value);
154
- if(setting < 1 || setting > 3)
155
- {
156
- rb_fireruby_raise(NULL,
157
- "Invalid dialect value specified for result set. "\
158
- "The dialect value must be between 1 and 3.");
159
- }
160
- }
161
- else
162
- {
109
+ VALUE sql, VALUE dialect, VALUE parameters) {
110
+ short setting = 0;
111
+ int type = 0,
112
+ inputs = 0,
113
+ outputs = 0;
114
+ long affected = 0;
115
+ ResultsHandle *results = NULL;
116
+ VALUE value = Qnil;
117
+ ConnectionHandle *cHandle = NULL;
118
+ TransactionHandle *tHandle = NULL;
119
+ XSQLDA *params = NULL;
120
+
121
+ /* Validate the inputs. */
122
+ if(TYPE(connection) == T_DATA &&
123
+ RDATA(connection)->dfree == (RUBY_DATA_FUNC)connectionFree) {
124
+ if(rb_funcall(connection, rb_intern("open?"), 0) == Qfalse) {
125
+ rb_fireruby_raise(NULL, "Closed connection specified for result set.");
126
+ }
127
+ } else {
128
+ rb_fireruby_raise(NULL, "Invalid connection specified for result set.");
129
+ }
130
+
131
+ if(TYPE(transaction) == T_DATA &&
132
+ RDATA(transaction)->dfree == (RUBY_DATA_FUNC)transactionFree) {
133
+ if(rb_funcall(transaction, rb_intern("active?"), 0) == Qfalse) {
134
+ rb_fireruby_raise(NULL, "Inactive transaction specified for result set.");
135
+ }
136
+ } else {
137
+ rb_fireruby_raise(NULL, "Invalid transaction specified for result set.");
138
+ }
139
+
140
+ value = rb_funcall(dialect, rb_intern("to_i"), 0);
141
+ if(TYPE(value) == T_FIXNUM) {
142
+ setting = FIX2INT(value);
143
+ if(setting < 1 || setting > 3) {
163
144
  rb_fireruby_raise(NULL,
164
- "Invalid dialect value specified for result set. The "\
165
- "dialect value must be between 1 and 3.");
166
- }
167
-
168
- /* Prepare the result set. */
169
- Data_Get_Struct(connection, ConnectionHandle, cHandle);
170
- Data_Get_Struct(transaction, TransactionHandle, tHandle);
171
- Data_Get_Struct(self, ResultsHandle, results);
172
- prepare(&cHandle->handle, &tHandle->handle, StringValuePtr(sql), &results->handle,
173
- setting, &type, &inputs, &outputs);
174
-
175
- if(type != isc_info_sql_stmt_select &&
176
- type != isc_info_sql_stmt_select_for_upd &&
177
- type != isc_info_sql_stmt_exec_procedure)
178
- {
145
+ "Invalid dialect value specified for result set. " \
146
+ "The dialect value must be between 1 and 3.");
147
+ }
148
+ } else {
149
+ rb_fireruby_raise(NULL,
150
+ "Invalid dialect value specified for result set. The " \
151
+ "dialect value must be between 1 and 3.");
152
+ }
153
+
154
+ /* Prepare the result set. */
155
+ Data_Get_Struct(connection, ConnectionHandle, cHandle);
156
+ Data_Get_Struct(transaction, TransactionHandle, tHandle);
157
+ Data_Get_Struct(self, ResultsHandle, results);
158
+ prepare(&cHandle->handle, &tHandle->handle, StringValuePtr(sql), &results->handle,
159
+ setting, &type, &inputs, &outputs);
160
+
161
+ if(type != isc_info_sql_stmt_select &&
162
+ type != isc_info_sql_stmt_select_for_upd &&
163
+ type != isc_info_sql_stmt_exec_procedure) {
164
+ cleanupHandle(&results->handle);
165
+ rb_fireruby_raise(NULL,
166
+ "Non-query SQL statement specified for result set.");
167
+ }
168
+
169
+ rb_iv_set(self, "@connection", connection);
170
+ rb_iv_set(self, "@transaction", transaction);
171
+ rb_iv_set(self, "@sql", rb_funcall(sql, rb_intern("to_s"), 0));
172
+ rb_iv_set(self, "@dialect", value);
173
+ results->dialect = setting;
174
+
175
+ /* UNCOMMENT FOR DEBUGGING PURPOSES! */
176
+ /*strcpy(results->sql, StringValuePtr(sql));*/
177
+
178
+ /* Check if input parameters are needed. */
179
+ if(inputs > 0) {
180
+ VALUE value = Qnil;
181
+ int size = 0;
182
+
183
+ if(parameters == Qnil) {
179
184
  cleanupHandle(&results->handle);
180
185
  rb_fireruby_raise(NULL,
181
- "Non-query SQL statement specified for result set.");
182
- }
183
-
184
- rb_iv_set(self, "@connection", connection);
185
- rb_iv_set(self, "@transaction", transaction);
186
- rb_iv_set(self, "@sql", rb_funcall(sql, rb_intern("to_s"), 0));
187
- rb_iv_set(self, "@dialect", value);
188
- results->dialect = setting;
189
-
190
- /* UNCOMMENT FOR DEBUGGING PURPOSES! */
191
- /*strcpy(results->sql, StringValuePtr(sql));*/
192
-
193
- /* Check if input parameters are needed. */
194
- if(inputs > 0)
195
- {
196
- VALUE value = Qnil;
197
- int size = 0;
198
-
199
- if(parameters == Qnil)
200
- {
201
- cleanupHandle(&results->handle);
202
- rb_fireruby_raise(NULL,
203
- "Empty parameter list specified for result set.");
204
- }
205
-
206
- value = rb_funcall(parameters, rb_intern("size"), 0);
207
- size = TYPE(value) == T_FIXNUM ? FIX2INT(value) : NUM2INT(value);
208
- if(size < inputs)
209
- {
210
- cleanupHandle(&results->handle);
211
- rb_fireruby_raise(NULL,
212
- "Insufficient parameters specified for result set.");
213
- }
214
-
215
- /* Allocate the XSQLDA and populate it. */
216
- params = allocateInXSQLDA(inputs, &results->handle, setting);
217
- prepareDataArea(params);
218
- setParameters(params, parameters, self);
219
- }
220
-
221
- /* Allocate output storage. */
222
- results->output = allocateOutXSQLDA(outputs, &results->handle, setting);
223
- prepareDataArea(results->output);
224
-
225
- /* Execute the statement and clean up. */
226
- if(type == isc_info_sql_stmt_exec_procedure) {
227
- /* Execute with output params */
228
- execute_2(&tHandle->handle, &results->handle, setting, params, type,
229
- &affected, results->output);
230
- /* Initialize procedure output fetch */
231
- results->procedure_output_fetch_state = 0;
232
- /* Early resolve transaction */
233
- resolveResultsTransaction (results, "commit");
234
- } else {
235
- execute(&tHandle->handle, &results->handle, setting, params, type,
236
- &affected);
237
- }
238
- if(params != NULL)
239
- {
240
- releaseDataArea(params);
241
- }
242
-
243
- return(self);
186
+ "Empty parameter list specified for result set.");
187
+ }
188
+
189
+ value = rb_funcall(parameters, rb_intern("size"), 0);
190
+ size = TYPE(value) == T_FIXNUM ? FIX2INT(value) : NUM2INT(value);
191
+ if(size < inputs) {
192
+ cleanupHandle(&results->handle);
193
+ rb_fireruby_raise(NULL,
194
+ "Insufficient parameters specified for result set.");
195
+ }
196
+
197
+ /* Allocate the XSQLDA and populate it. */
198
+ params = allocateInXSQLDA(inputs, &results->handle, setting);
199
+ prepareDataArea(params);
200
+ setParameters(params, parameters, self);
201
+ }
202
+
203
+ /* Allocate output storage. */
204
+ results->output = allocateOutXSQLDA(outputs, &results->handle, setting);
205
+ prepareDataArea(results->output);
206
+
207
+ /* Execute the statement and clean up. */
208
+ if(type == isc_info_sql_stmt_exec_procedure) {
209
+ /* Execute with output params */
210
+ execute_2(&tHandle->handle, &results->handle, setting, params, type,
211
+ &affected, results->output);
212
+ /* Initialize procedure output fetch */
213
+ results->procedure_output_fetch_state = 0;
214
+ /* Early resolve transaction */
215
+ resolveResultsTransaction (results, "commit");
216
+ } else {
217
+ execute(&tHandle->handle, &results->handle, setting, params, type,
218
+ &affected);
219
+ }
220
+ if(params != NULL) {
221
+ releaseDataArea(params);
222
+ }
223
+
224
+ return(self);
244
225
  }
245
226
 
246
227
 
@@ -252,44 +233,41 @@ VALUE initializeResultSet(VALUE self, VALUE connection, VALUE transaction,
252
233
  * @return Either a reference to a Row object or nil.
253
234
  *
254
235
  */
255
- VALUE fetchResultSetEntry(VALUE self)
256
- {
257
- VALUE row = Qnil;
258
- ResultsHandle *results = NULL;
259
- ISC_STATUS status[20],
260
- value;
261
-
262
- Data_Get_Struct(self, ResultsHandle, results);
263
- if(results->handle != 0)
264
- {
265
- VALUE array,number;
266
- value = results->procedure_output_fetch_state;
267
- if(value < 0) {
268
- value = isc_dsql_fetch(status, &results->handle, results->dialect,
269
- results->output);
270
- } else {
271
- /* move procedure_output_fetch_state ahead - fetch only one row */
272
- results->procedure_output_fetch_state = 100;
273
- }
274
- array = Qnil;
275
- number = Qnil;
276
- switch(value)
277
- {
278
- case 0 :
279
- array = toArray(self);
280
- number = INT2NUM(++(results->fetched));
281
- row = rb_row_new(self, array, number);
282
- break;
283
- case 100 :
284
- results->exhausted = 1;
285
- resolveResultsTransaction(results, "commit");
286
- break;
287
- default :
288
- rb_fireruby_raise(status, "Error fetching query row.");
289
- }
290
- }
291
-
292
- return(row);
236
+ VALUE fetchResultSetEntry(VALUE self) {
237
+ VALUE row = Qnil;
238
+ ResultsHandle *results = NULL;
239
+ ISC_STATUS status[ISC_STATUS_LENGTH],
240
+ value;
241
+
242
+ Data_Get_Struct(self, ResultsHandle, results);
243
+ if(results->handle != 0) {
244
+ VALUE array,number;
245
+ value = results->procedure_output_fetch_state;
246
+ if(value < 0) {
247
+ value = isc_dsql_fetch(status, &results->handle, results->dialect,
248
+ results->output);
249
+ } else {
250
+ /* move procedure_output_fetch_state ahead - fetch only one row */
251
+ results->procedure_output_fetch_state = 100;
252
+ }
253
+ array = Qnil;
254
+ number = Qnil;
255
+ switch(value) {
256
+ case 0:
257
+ array = toArray(self);
258
+ number = INT2NUM(++(results->fetched));
259
+ row = rb_row_new(self, array, number);
260
+ break;
261
+ case 100:
262
+ results->exhausted = 1;
263
+ resolveResultsTransaction(results, "commit");
264
+ break;
265
+ default:
266
+ rb_fireruby_raise(status, "Error fetching query row.");
267
+ }
268
+ }
269
+
270
+ return(row);
293
271
  }
294
272
 
295
273
 
@@ -302,31 +280,27 @@ VALUE fetchResultSetEntry(VALUE self)
302
280
  * @return A reference to the closed ResultSet object.
303
281
  *
304
282
  */
305
- VALUE closeResultSet(VALUE self)
306
- {
307
- ResultsHandle *results = NULL;
308
-
309
- Data_Get_Struct(self, ResultsHandle, results);
310
- if(results->handle != 0)
311
- {
312
- ISC_STATUS status[20];
313
-
314
- if(isc_dsql_free_statement(status, &results->handle, DSQL_drop))
315
- {
316
- rb_fireruby_raise(status, "Error closing result set.");
317
- }
318
- results->handle = 0;
319
- }
320
-
321
- if(results->output != NULL)
322
- {
323
- releaseDataArea(results->output);
324
- results->output = NULL;
325
- }
326
-
327
- resolveResultsTransaction(results, "commit");
328
-
329
- return(self);
283
+ VALUE closeResultSet(VALUE self) {
284
+ ResultsHandle *results = NULL;
285
+
286
+ Data_Get_Struct(self, ResultsHandle, results);
287
+ if(results->handle != 0) {
288
+ ISC_STATUS status[ISC_STATUS_LENGTH];
289
+
290
+ if(isc_dsql_free_statement(status, &results->handle, DSQL_drop)) {
291
+ rb_fireruby_raise(status, "Error closing result set.");
292
+ }
293
+ results->handle = 0;
294
+ }
295
+
296
+ if(results->output != NULL) {
297
+ releaseDataArea(results->output);
298
+ results->output = NULL;
299
+ }
300
+
301
+ resolveResultsTransaction(results, "commit");
302
+
303
+ return(self);
330
304
  }
331
305
 
332
306
 
@@ -340,13 +314,12 @@ VALUE closeResultSet(VALUE self)
340
314
  * fetched from the ResultSet so far.
341
315
  *
342
316
  */
343
- VALUE getResultSetCount(VALUE self)
344
- {
345
- ResultsHandle *results = NULL;
346
-
347
- Data_Get_Struct(self, ResultsHandle, results);
348
-
349
- return(INT2NUM(results->fetched));
317
+ VALUE getResultSetCount(VALUE self) {
318
+ ResultsHandle *results = NULL;
319
+
320
+ Data_Get_Struct(self, ResultsHandle, results);
321
+
322
+ return(INT2NUM(results->fetched));
350
323
  }
351
324
 
352
325
 
@@ -360,9 +333,8 @@ VALUE getResultSetCount(VALUE self)
360
333
  * @return A reference to the requested attribute object.
361
334
  *
362
335
  */
363
- VALUE getResultSetConnection(VALUE self)
364
- {
365
- return(rb_iv_get(self, "@connection"));
336
+ VALUE getResultSetConnection(VALUE self) {
337
+ return(rb_iv_get(self, "@connection"));
366
338
  }
367
339
 
368
340
 
@@ -376,9 +348,8 @@ VALUE getResultSetConnection(VALUE self)
376
348
  * @return A reference to the requested attribute object.
377
349
  *
378
350
  */
379
- VALUE getResultSetTransaction(VALUE self)
380
- {
381
- return(rb_iv_get(self, "@transaction"));
351
+ VALUE getResultSetTransaction(VALUE self) {
352
+ return(rb_iv_get(self, "@transaction"));
382
353
  }
383
354
 
384
355
 
@@ -391,9 +362,8 @@ VALUE getResultSetTransaction(VALUE self)
391
362
  * @return A reference to the requested attribute object.
392
363
  *
393
364
  */
394
- VALUE getResultSetSQL(VALUE self)
395
- {
396
- return(rb_iv_get(self, "@sql"));
365
+ VALUE getResultSetSQL(VALUE self) {
366
+ return(rb_iv_get(self, "@sql"));
397
367
  }
398
368
 
399
369
 
@@ -406,9 +376,8 @@ VALUE getResultSetSQL(VALUE self)
406
376
  * @return A reference to the requested attribute object.
407
377
  *
408
378
  */
409
- VALUE getResultSetDialect(VALUE self)
410
- {
411
- return(rb_iv_get(self, "@dialect"));
379
+ VALUE getResultSetDialect(VALUE self) {
380
+ return(rb_iv_get(self, "@dialect"));
412
381
  }
413
382
 
414
383
 
@@ -421,18 +390,16 @@ VALUE getResultSetDialect(VALUE self)
421
390
  * @return A reference to an integer containing the column count.
422
391
  *
423
392
  */
424
- VALUE getResultSetColumnCount(VALUE self)
425
- {
426
- VALUE count = Qnil;
427
- ResultsHandle *results = NULL;
428
-
429
- Data_Get_Struct(self, ResultsHandle, results);
430
- if(results != NULL)
431
- {
432
- count = INT2NUM(results->output->sqld);
433
- }
434
-
435
- return(count);
393
+ VALUE getResultSetColumnCount(VALUE self) {
394
+ VALUE count = Qnil;
395
+ ResultsHandle *results = NULL;
396
+
397
+ Data_Get_Struct(self, ResultsHandle, results);
398
+ if(results != NULL) {
399
+ count = INT2NUM(results->output->sqld);
400
+ }
401
+
402
+ return(count);
436
403
  }
437
404
 
438
405
 
@@ -447,28 +414,25 @@ VALUE getResultSetColumnCount(VALUE self)
447
414
  * was specified.
448
415
  *
449
416
  */
450
- static VALUE getResultSetColumnName(VALUE self, VALUE column)
451
- {
452
- VALUE name = Qnil;
453
- ResultsHandle *results = NULL;
454
-
455
- Data_Get_Struct(self, ResultsHandle, results);
456
- if(results != NULL)
457
- {
458
- int offset = 0;
459
-
460
- offset = (TYPE(column) == T_FIXNUM ? FIX2INT(column) : NUM2INT(column));
461
- if(offset >= 0 && offset < results->output->sqld)
462
- {
463
- XSQLVAR *var = results->output->sqlvar;
464
- int index;
465
-
466
- for(index = 0; index < offset; index++, var++);
467
- name = rb_str_new(var->sqlname, var->sqlname_length);
468
- }
469
- }
470
-
471
- return(name);
417
+ static VALUE getResultSetColumnName(VALUE self, VALUE column) {
418
+ VALUE name = Qnil;
419
+ ResultsHandle *results = NULL;
420
+
421
+ Data_Get_Struct(self, ResultsHandle, results);
422
+ if(results != NULL) {
423
+ int offset = 0;
424
+
425
+ offset = (TYPE(column) == T_FIXNUM ? FIX2INT(column) : NUM2INT(column));
426
+ if(offset >= 0 && offset < results->output->sqld) {
427
+ XSQLVAR *var = results->output->sqlvar;
428
+ int index;
429
+
430
+ for(index = 0; index < offset; index++, var++) ;
431
+ name = rb_str_new(var->sqlname, var->sqlname_length);
432
+ }
433
+ }
434
+
435
+ return(name);
472
436
  }
473
437
 
474
438
 
@@ -483,28 +447,57 @@ static VALUE getResultSetColumnName(VALUE self, VALUE column)
483
447
  * was specified.
484
448
  *
485
449
  */
486
- static VALUE getResultSetColumnAlias(VALUE self, VALUE column)
487
- {
488
- VALUE alias = Qnil;
489
- ResultsHandle *results = NULL;
490
-
491
- Data_Get_Struct(self, ResultsHandle, results);
492
- if(results != NULL)
493
- {
494
- int offset = 0;
495
-
496
- offset = (TYPE(column) == T_FIXNUM ? FIX2INT(column) : NUM2INT(column));
497
- if(offset >= 0 && offset < results->output->sqld)
498
- {
499
- XSQLVAR *var = results->output->sqlvar;
500
- int index;
501
-
502
- for(index = 0; index < offset; index++, var++);
503
- alias = rb_str_new(var->aliasname, var->aliasname_length);
504
- }
505
- }
506
-
507
- return(alias);
450
+ static VALUE getResultSetColumnAlias(VALUE self, VALUE column) {
451
+ VALUE alias = Qnil;
452
+ ResultsHandle *results = NULL;
453
+
454
+ Data_Get_Struct(self, ResultsHandle, results);
455
+ if(results != NULL) {
456
+ int offset = 0;
457
+
458
+ offset = (TYPE(column) == T_FIXNUM ? FIX2INT(column) : NUM2INT(column));
459
+ if(offset >= 0 && offset < results->output->sqld) {
460
+ XSQLVAR *var = results->output->sqlvar;
461
+ int index;
462
+
463
+ for(index = 0; index < offset; index++, var++) ;
464
+ alias = rb_str_new(var->aliasname, var->aliasname_length);
465
+ }
466
+ }
467
+
468
+ return(alias);
469
+ }
470
+
471
+ /**
472
+ * This function provides the column_scale method for the ResultSet class.
473
+ *
474
+ * @param self A reference to the ResultSet object to retrieve the column
475
+ * alias from.
476
+ * @param column An offset to the column to retrieve the scale of.
477
+ *
478
+ * @return An Integer representing the sqlscale of the column, or nil if an
479
+ * invalid column was specified.
480
+ *
481
+ */
482
+ static VALUE getResultSetColumnScale(VALUE self, VALUE column) {
483
+ VALUE scale = Qnil;
484
+ ResultsHandle *results = NULL;
485
+
486
+ Data_Get_Struct(self, ResultsHandle, results);
487
+ if(results != NULL) {
488
+ int offset = 0;
489
+
490
+ offset = (TYPE(column) == T_FIXNUM ? FIX2INT(column) : NUM2INT(column));
491
+ if(offset >= 0 && offset < results->output->sqld) {
492
+ XSQLVAR *var = results->output->sqlvar;
493
+ int index;
494
+
495
+ for(index = 0; index < offset; index++, var++) ;
496
+ scale = INT2FIX(var->sqlscale);
497
+ }
498
+ }
499
+
500
+ return(scale);
508
501
  }
509
502
 
510
503
 
@@ -519,28 +512,25 @@ static VALUE getResultSetColumnAlias(VALUE self, VALUE column)
519
512
  * column was specified.
520
513
  *
521
514
  */
522
- static VALUE getResultSetColumnTable(VALUE self, VALUE column)
523
- {
524
- VALUE name = Qnil;
525
- ResultsHandle *results = NULL;
526
-
527
- Data_Get_Struct(self, ResultsHandle, results);
528
- if(results != NULL)
529
- {
530
- int offset = 0;
531
-
532
- offset = (TYPE(column) == T_FIXNUM ? FIX2INT(column) : NUM2INT(column));
533
- if(offset >= 0 && offset < results->output->sqld)
534
- {
535
- XSQLVAR *var = results->output->sqlvar;
536
- int index;
537
-
538
- for(index = 0; index < offset; index++, var++);
539
- name = rb_str_new(var->relname, var->relname_length);
540
- }
541
- }
542
-
543
- return(name);
515
+ static VALUE getResultSetColumnTable(VALUE self, VALUE column) {
516
+ VALUE name = Qnil;
517
+ ResultsHandle *results = NULL;
518
+
519
+ Data_Get_Struct(self, ResultsHandle, results);
520
+ if(results != NULL) {
521
+ int offset = 0;
522
+
523
+ offset = (TYPE(column) == T_FIXNUM ? FIX2INT(column) : NUM2INT(column));
524
+ if(offset >= 0 && offset < results->output->sqld) {
525
+ XSQLVAR *var = results->output->sqlvar;
526
+ int index;
527
+
528
+ for(index = 0; index < offset; index++, var++) ;
529
+ name = rb_str_new(var->relname, var->relname_length);
530
+ }
531
+ }
532
+
533
+ return(name);
544
534
  }
545
535
 
546
536
 
@@ -554,34 +544,29 @@ static VALUE getResultSetColumnTable(VALUE self, VALUE column)
554
544
  * @return A Symbol representing the basic data type.
555
545
  *
556
546
  */
557
- static VALUE getResultSetColumnType(VALUE self, VALUE column)
558
- {
559
- VALUE type = toSymbol("UNKNOWN");
560
-
561
- if(TYPE(column) == T_FIXNUM)
562
- {
563
- ResultsHandle *handle = NULL;
564
-
565
- Data_Get_Struct(self, ResultsHandle, handle);
566
- if(handle != NULL)
567
- {
568
- int index = FIX2INT(column);
569
-
570
- /* Fix negative index values. */
571
- if(index < 0)
572
- {
573
- index = handle->output->sqln + index;
574
- }
575
-
576
- if(index >= 0 && index < handle->output->sqln)
577
- {
578
- type = getColumnType(&handle->output->sqlvar[index]);
579
- }
547
+ static VALUE getResultSetColumnType(VALUE self, VALUE column) {
548
+ VALUE type = toSymbol("UNKNOWN");
549
+
550
+ if(TYPE(column) == T_FIXNUM) {
551
+ ResultsHandle *handle = NULL;
552
+
553
+ Data_Get_Struct(self, ResultsHandle, handle);
554
+ if(handle != NULL) {
555
+ int index = FIX2INT(column);
556
+
557
+ /* Fix negative index values. */
558
+ if(index < 0) {
559
+ index = handle->output->sqln + index;
580
560
  }
581
- }
582
-
583
-
584
- return(type);
561
+
562
+ if(index >= 0 && index < handle->output->sqln) {
563
+ type = getColumnType(&handle->output->sqlvar[index]);
564
+ }
565
+ }
566
+ }
567
+
568
+
569
+ return(type);
585
570
  }
586
571
 
587
572
 
@@ -594,22 +579,19 @@ static VALUE getResultSetColumnType(VALUE self, VALUE column)
594
579
  * nil.
595
580
  *
596
581
  */
597
- VALUE eachResultSetRow(VALUE self)
598
- {
599
- VALUE result = Qnil;
600
-
601
- /* Check if a block was provided. */
602
- if(rb_block_given_p())
603
- {
604
- VALUE row;
605
-
606
- while((row = fetchResultSetEntry(self)) != Qnil)
607
- {
608
- result = rb_yield(row);
609
- }
610
- }
611
-
612
- return(result);
582
+ VALUE eachResultSetRow(VALUE self) {
583
+ VALUE result = Qnil;
584
+
585
+ /* Check if a block was provided. */
586
+ if(rb_block_given_p()) {
587
+ VALUE row;
588
+
589
+ while((row = fetchResultSetEntry(self)) != Qnil) {
590
+ result = rb_yield(row);
591
+ }
592
+ }
593
+
594
+ return(result);
613
595
  }
614
596
 
615
597
 
@@ -622,18 +604,16 @@ VALUE eachResultSetRow(VALUE self)
622
604
  * if they haven't.
623
605
  *
624
606
  */
625
- VALUE isResultSetExhausted(VALUE self)
626
- {
627
- VALUE exhausted = Qfalse;
628
- ResultsHandle *results = NULL;
629
-
630
- Data_Get_Struct(self, ResultsHandle, results);
631
- if(results->exhausted)
632
- {
633
- exhausted = Qtrue;
634
- }
635
-
636
- return(exhausted);
607
+ VALUE isResultSetExhausted(VALUE self) {
608
+ VALUE exhausted = Qfalse;
609
+ ResultsHandle *results = NULL;
610
+
611
+ Data_Get_Struct(self, ResultsHandle, results);
612
+ if(results->exhausted) {
613
+ exhausted = Qtrue;
614
+ }
615
+
616
+ return(exhausted);
637
617
  }
638
618
 
639
619
 
@@ -646,17 +626,14 @@ VALUE isResultSetExhausted(VALUE self)
646
626
  * being scanned by the garbage collector.
647
627
  *
648
628
  */
649
- void resultSetMark(void *handle)
650
- {
651
- ResultsHandle *results = (ResultsHandle *)handle;
652
-
653
- if(results != NULL)
654
- {
655
- if(results->transaction != Qnil)
656
- {
657
- rb_gc_mark(results->transaction);
658
- }
659
- }
629
+ void resultSetMark(void *handle) {
630
+ ResultsHandle *results = (ResultsHandle *)handle;
631
+
632
+ if(results != NULL) {
633
+ if(results->transaction != Qnil) {
634
+ rb_gc_mark(results->transaction);
635
+ }
636
+ }
660
637
  }
661
638
 
662
639
 
@@ -678,14 +655,13 @@ void resultSetMark(void *handle)
678
655
  *
679
656
  */
680
657
  VALUE rb_result_set_new(VALUE connection, VALUE transaction, VALUE sql,
681
- VALUE dialect, VALUE parameters)
682
- {
683
- VALUE instance = allocateResultSet(cResultSet);
684
-
685
- initializeResultSet(instance, connection, transaction, sql, dialect,
686
- parameters);
687
-
688
- return(instance);
658
+ VALUE dialect, VALUE parameters) {
659
+ VALUE instance = allocateResultSet(cResultSet);
660
+
661
+ initializeResultSet(instance, connection, transaction, sql, dialect,
662
+ parameters);
663
+
664
+ return(instance);
689
665
  }
690
666
 
691
667
 
@@ -699,12 +675,11 @@ VALUE rb_result_set_new(VALUE connection, VALUE transaction, VALUE sql,
699
675
  * is assuming responsibility for.
700
676
  *
701
677
  */
702
- void rb_assign_transaction(VALUE set, VALUE transaction)
703
- {
704
- ResultsHandle *results = NULL;
705
-
706
- Data_Get_Struct(set, ResultsHandle, results);
707
- results->transaction = transaction;
678
+ void rb_assign_transaction(VALUE set, VALUE transaction) {
679
+ ResultsHandle *results = NULL;
680
+
681
+ Data_Get_Struct(set, ResultsHandle, results);
682
+ results->transaction = transaction;
708
683
  }
709
684
 
710
685
 
@@ -716,29 +691,25 @@ void rb_assign_transaction(VALUE set, VALUE transaction)
716
691
  * object being collected.
717
692
  *
718
693
  */
719
- void resultSetFree(void *handle)
720
- {
721
- if(handle != NULL)
722
- {
723
- ResultsHandle *results = (ResultsHandle *)handle;
724
-
725
- if(results->handle != 0)
726
- {
727
- ISC_STATUS status[20];
728
-
729
- /* UNCOMMENT FOR DEBUG PURPOSES! */
730
- /*fprintf(stderr, "Releasing statement handle for...\n%s\n", results->sql);*/
731
- isc_dsql_free_statement(status, &results->handle, DSQL_drop);
732
- }
733
-
734
- if(results->output != NULL)
735
- {
736
- releaseDataArea(results->output);
737
- }
738
-
739
- resolveResultsTransaction(results, "rollback");
740
- free(results);
741
- }
694
+ void resultSetFree(void *handle) {
695
+ if(handle != NULL) {
696
+ ResultsHandle *results = (ResultsHandle *)handle;
697
+
698
+ if(results->handle != 0) {
699
+ ISC_STATUS status[ISC_STATUS_LENGTH];
700
+
701
+ /* UNCOMMENT FOR DEBUG PURPOSES! */
702
+ /*fprintf(stderr, "Releasing statement handle for...\n%s\n", results->sql);*/
703
+ isc_dsql_free_statement(status, &results->handle, DSQL_drop);
704
+ }
705
+
706
+ if(results->output != NULL) {
707
+ releaseDataArea(results->output);
708
+ }
709
+
710
+ resolveResultsTransaction(results, "rollback");
711
+ free(results);
712
+ }
742
713
  }
743
714
 
744
715
 
@@ -748,16 +719,14 @@ void resultSetFree(void *handle)
748
719
  * @param handle A pointer to the statement handle to be cleaned up.
749
720
  *
750
721
  */
751
- void cleanupHandle(isc_stmt_handle *handle)
752
- {
753
- if(*handle != 0)
754
- {
755
- ISC_STATUS status[20];
756
-
757
- /* UNCOMMENT FOR DEBUG PURPOSES! */
758
- /*fprintf(stderr, "Cleaning up a statement handle.\n");*/
759
- isc_dsql_free_statement(status, handle, DSQL_drop);
760
- }
722
+ void cleanupHandle(isc_stmt_handle *handle) {
723
+ if(*handle != 0) {
724
+ ISC_STATUS status[ISC_STATUS_LENGTH];
725
+
726
+ /* UNCOMMENT FOR DEBUG PURPOSES! */
727
+ /*fprintf(stderr, "Cleaning up a statement handle.\n");*/
728
+ isc_dsql_free_statement(status, handle, DSQL_drop);
729
+ }
761
730
  }
762
731
 
763
732
 
@@ -769,13 +738,11 @@ void cleanupHandle(isc_stmt_handle *handle)
769
738
  * @param resolveMethod - transaction resolving method - eg. commit, rollback
770
739
  *
771
740
  */
772
- void resolveResultsTransaction(ResultsHandle *results, char *resolveMethod)
773
- {
774
- if(results->transaction != Qnil)
775
- {
776
- rb_funcall(results->transaction, rb_intern(resolveMethod), 0);
777
- results->transaction = Qnil;
778
- }
741
+ void resolveResultsTransaction(ResultsHandle *results, char *resolveMethod) {
742
+ if(results->transaction != Qnil) {
743
+ rb_funcall(results->transaction, rb_intern(resolveMethod), 0);
744
+ results->transaction = Qnil;
745
+ }
779
746
  }
780
747
 
781
748
 
@@ -786,25 +753,25 @@ void resolveResultsTransaction(ResultsHandle *results, char *resolveMethod)
786
753
  * @param module A reference to the module to create the class within.
787
754
  *
788
755
  */
789
- void Init_ResultSet(VALUE module)
790
- {
791
- cResultSet = rb_define_class_under(module, "ResultSet", rb_cObject);
792
- rb_define_alloc_func(cResultSet, allocateResultSet);
793
- rb_include_module(cResultSet, rb_mEnumerable);
794
- rb_define_method(cResultSet, "initialize", initializeResultSet, 5);
795
- rb_define_method(cResultSet, "initialize_copy", forbidObjectCopy, 1);
796
- rb_define_method(cResultSet, "row_count", getResultSetCount, 0);
797
- rb_define_method(cResultSet, "fetch", fetchResultSetEntry, 0);
798
- rb_define_method(cResultSet, "close", closeResultSet, 0);
799
- rb_define_method(cResultSet, "connection", getResultSetConnection, 0);
800
- rb_define_method(cResultSet, "transaction", getResultSetTransaction, 0);
801
- rb_define_method(cResultSet, "sql", getResultSetSQL, 0);
802
- rb_define_method(cResultSet, "dialect", getResultSetDialect, 0);
803
- rb_define_method(cResultSet, "each", eachResultSetRow, 0);
804
- rb_define_method(cResultSet, "column_name", getResultSetColumnName, 1);
805
- rb_define_method(cResultSet, "column_alias", getResultSetColumnAlias, 1);
806
- rb_define_method(cResultSet, "column_table", getResultSetColumnTable, 1);
807
- rb_define_method(cResultSet, "column_count", getResultSetColumnCount, 0);
808
- rb_define_method(cResultSet, "exhausted?", isResultSetExhausted, 0);
809
- rb_define_method(cResultSet, "get_base_type", getResultSetColumnType, 1);
756
+ void Init_ResultSet(VALUE module) {
757
+ cResultSet = rb_define_class_under(module, "ResultSet", rb_cObject);
758
+ rb_define_alloc_func(cResultSet, allocateResultSet);
759
+ rb_include_module(cResultSet, rb_mEnumerable);
760
+ rb_define_method(cResultSet, "initialize", initializeResultSet, 5);
761
+ rb_define_method(cResultSet, "initialize_copy", forbidObjectCopy, 1);
762
+ rb_define_method(cResultSet, "row_count", getResultSetCount, 0);
763
+ rb_define_method(cResultSet, "fetch", fetchResultSetEntry, 0);
764
+ rb_define_method(cResultSet, "close", closeResultSet, 0);
765
+ rb_define_method(cResultSet, "connection", getResultSetConnection, 0);
766
+ rb_define_method(cResultSet, "transaction", getResultSetTransaction, 0);
767
+ rb_define_method(cResultSet, "sql", getResultSetSQL, 0);
768
+ rb_define_method(cResultSet, "dialect", getResultSetDialect, 0);
769
+ rb_define_method(cResultSet, "each", eachResultSetRow, 0);
770
+ rb_define_method(cResultSet, "column_name", getResultSetColumnName, 1);
771
+ rb_define_method(cResultSet, "column_alias", getResultSetColumnAlias, 1);
772
+ rb_define_method(cResultSet, "column_scale", getResultSetColumnScale, 1);
773
+ rb_define_method(cResultSet, "column_table", getResultSetColumnTable, 1);
774
+ rb_define_method(cResultSet, "column_count", getResultSetColumnCount, 0);
775
+ rb_define_method(cResultSet, "exhausted?", isResultSetExhausted, 0);
776
+ rb_define_method(cResultSet, "get_base_type", getResultSetColumnType, 1);
810
777
  }