ibm_db 4.0.0 → 5.1.0

Sign up to get free protection for your applications and to get access to all the features.
Files changed (51) hide show
  1. checksums.yaml +5 -5
  2. data/README +2 -2
  3. data/ext/Makefile +266 -0
  4. data/ext/Makefile.nt32.191 +1 -1
  5. data/ext/extconf.rb +38 -7
  6. data/ext/gil_release_version.h +3 -0
  7. data/ext/ibm_db.c +387 -395
  8. data/ext/ibm_db.o +0 -0
  9. data/ext/ibm_db.so +0 -0
  10. data/ext/mkmf.log +103 -0
  11. data/ext/ruby_ibm_db.h +1 -1
  12. data/ext/ruby_ibm_db_cli.c +23 -23
  13. data/ext/ruby_ibm_db_cli.h +5 -5
  14. data/ext/ruby_ibm_db_cli.o +0 -0
  15. data/ext/unicode_support_version.h +3 -0
  16. data/lib/active_record/connection_adapters/ibm_db_adapter.rb +348 -207
  17. data/test/cases/attribute_decorators_test.rb +2 -1
  18. data/test/cases/cache_key_test.rb +2 -1
  19. data/test/cases/comment_test.rb +4 -2
  20. data/test/cases/date_time_precision_test.rb +2 -1
  21. data/test/cases/defaults_test.rb +2 -1
  22. data/test/cases/migration/foreign_key_test.rb +4 -2
  23. data/test/cases/migration/helper.rb +1 -1
  24. data/test/cases/migration/references_foreign_key_test.rb +10 -5
  25. data/test/cases/migrator_test.rb +2 -1
  26. data/test/cases/schema_dumper_test.rb +3 -3
  27. data/test/cases/time_precision_test.rb +2 -1
  28. data/test/cases/transactions_test.rb +3 -2
  29. data/test/config.yml +154 -154
  30. data/test/connections/native_ibm_db/connection.rb +44 -0
  31. data/test/fixtures/admin/randomly_named_a9.yml +7 -7
  32. data/test/fixtures/admin/randomly_named_b0.yml +7 -7
  33. data/test/fixtures/developers.yml +1 -1
  34. data/test/fixtures/pirates.yml +0 -3
  35. data/test/fixtures/randomly_named_a9.yml +7 -7
  36. data/test/ibm_db_test.rb +24 -24
  37. data/test/models/admin.rb +1 -1
  38. data/test/models/admin/account.rb +1 -1
  39. data/test/models/admin/randomly_named_c1.rb +7 -7
  40. data/test/models/binary.rb +1 -1
  41. data/test/models/event.rb +1 -1
  42. data/test/models/guid.rb +1 -1
  43. data/test/models/randomly_named_c1.rb +3 -3
  44. data/test/models/ship_part.rb +1 -1
  45. data/test/schema/i5/ibm_db_specific_schema.rb +137 -0
  46. data/test/schema/ids/ibm_db_specific_schema.rb +140 -0
  47. data/test/schema/luw/ibm_db_specific_schema.rb +137 -0
  48. data/test/schema/zOS/ibm_db_specific_schema.rb +208 -0
  49. metadata +27 -13
  50. data/test/fixtures/author_addresses.original +0 -11
  51. data/test/fixtures/authors.original +0 -17
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
- SHA1:
3
- metadata.gz: 5071f03ae2c3ba13cec598b8c2594f9b84f21f5c
4
- data.tar.gz: 216189862653b8f643f7a433f87e1f715311a016
2
+ SHA256:
3
+ metadata.gz: 31e8f41e222f638241d0797fa0d898d0152372df6bf6479477299e3ef0f1accc
4
+ data.tar.gz: d8711fcf90d18465ad55a76c8661bdcd17a683652f0b08389fdbfcd578099fae
5
5
  SHA512:
6
- metadata.gz: e2c6dbe5f93dbbb81ced747920498c4a22e60d669dc1e2784e87ec9677fe3dc3bd29c27422a992e04a6f9ae0c759de158e1d490f28f285a9bbb7edb2533b2326
7
- data.tar.gz: e4e7860957ce5cdf80f7ba53a476b292551e45fe2c7e2065984bf4eb1833275be82e81929b3e9a664513900f7dd225f9c43a8a9cb6830c5e0bcb8dcdba02b393
6
+ metadata.gz: bc300c1dace4fc524b5f6124dbe51d4000be3fb6a1556083dc3d5a5798ab62cfb058aa248db7f7b308bbcebc8705956c241bf606089f07e19f4b9b0f7dc00d71
7
+ data.tar.gz: 9c0ea6ac28a2ad48902ad4e539c952d294f461fc6ee391ea8df27278d21dc8b6c54a960778eb57db08a8752992b78335c83fe772948b58242ceb430f75b962b0
data/README CHANGED
@@ -1,5 +1,5 @@
1
1
  =====================================================================
2
- README for the IBM_DB Adapter (4.0.0) and Driver (3.0.5) (2018/05/24)
2
+ README for the IBM_DB Adapter (5.0.0) and Driver (3.0.5)
3
3
  For ActiveRecord Version >= 5.0.7 (and Rails >= 5.0.7)
4
4
  =====================================================================
5
5
 
@@ -113,7 +113,7 @@ here only for reference.
113
113
  Build the driver:
114
114
  - $ cd rubyibm_source/IBM_DB_Adapter/ibm_db/ext
115
115
  - $ ruby extconf.rb
116
- - $ make
116
+ - $ ridk exec make
117
117
 
118
118
  Build the ibm_db gem
119
119
  - $ cp rubyibm_source/IBM_DB_Adapter/ibm_db/ext/ibm_db.so rubyibm_source/IBM_DB_Adapter/ibm_db/lib
data/ext/Makefile ADDED
@@ -0,0 +1,266 @@
1
+
2
+ SHELL = /bin/sh
3
+
4
+ # V=0 quiet, V=1 verbose. other values don't work.
5
+ V = 0
6
+ Q1 = $(V:1=)
7
+ Q = $(Q1:0=@)
8
+ ECHO1 = $(V:1=@ :)
9
+ ECHO = $(ECHO1:0=@ echo)
10
+ NULLCMD = :
11
+
12
+ #### Start of system configuration section. ####
13
+
14
+ srcdir = .
15
+ topdir = /home/rakhil/ruby_exe/include/ruby-2.6.0
16
+ hdrdir = $(topdir)
17
+ arch_hdrdir = /home/rakhil/ruby_exe/include/ruby-2.6.0/x86_64-linux
18
+ PATH_SEPARATOR = :
19
+ VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
20
+ prefix = $(DESTDIR)/home/rakhil/ruby_exe
21
+ rubysitearchprefix = $(rubylibprefix)/$(sitearch)
22
+ rubyarchprefix = $(rubylibprefix)/$(arch)
23
+ rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
24
+ exec_prefix = $(prefix)
25
+ vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
26
+ sitearchhdrdir = $(sitehdrdir)/$(sitearch)
27
+ rubyarchhdrdir = $(rubyhdrdir)/$(arch)
28
+ vendorhdrdir = $(rubyhdrdir)/vendor_ruby
29
+ sitehdrdir = $(rubyhdrdir)/site_ruby
30
+ rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
31
+ vendorarchdir = $(vendorlibdir)/$(sitearch)
32
+ vendorlibdir = $(vendordir)/$(ruby_version)
33
+ vendordir = $(rubylibprefix)/vendor_ruby
34
+ sitearchdir = $(sitelibdir)/$(sitearch)
35
+ sitelibdir = $(sitedir)/$(ruby_version)
36
+ sitedir = $(rubylibprefix)/site_ruby
37
+ rubyarchdir = $(rubylibdir)/$(arch)
38
+ rubylibdir = $(rubylibprefix)/$(ruby_version)
39
+ sitearchincludedir = $(includedir)/$(sitearch)
40
+ archincludedir = $(includedir)/$(arch)
41
+ sitearchlibdir = $(libdir)/$(sitearch)
42
+ archlibdir = $(libdir)/$(arch)
43
+ ridir = $(datarootdir)/$(RI_BASE_NAME)
44
+ mandir = $(datarootdir)/man
45
+ localedir = $(datarootdir)/locale
46
+ libdir = $(exec_prefix)/lib
47
+ psdir = $(docdir)
48
+ pdfdir = $(docdir)
49
+ dvidir = $(docdir)
50
+ htmldir = $(docdir)
51
+ infodir = $(datarootdir)/info
52
+ docdir = $(datarootdir)/doc/$(PACKAGE)
53
+ oldincludedir = $(DESTDIR)/usr/include
54
+ includedir = $(prefix)/include
55
+ runstatedir = $(localstatedir)/run
56
+ localstatedir = $(prefix)/var
57
+ sharedstatedir = $(prefix)/com
58
+ sysconfdir = $(prefix)/etc
59
+ datadir = $(datarootdir)
60
+ datarootdir = $(prefix)/share
61
+ libexecdir = $(exec_prefix)/libexec
62
+ sbindir = $(exec_prefix)/sbin
63
+ bindir = $(exec_prefix)/bin
64
+ archdir = $(rubyarchdir)
65
+
66
+
67
+ CC_WRAPPER =
68
+ CC = gcc
69
+ CXX = g++
70
+ LIBRUBY = $(LIBRUBY_A)
71
+ LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
72
+ LIBRUBYARG_SHARED = -Wl,-rpath,$(libdir) -L$(libdir)
73
+ LIBRUBYARG_STATIC = -Wl,-rpath,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static $(MAINLIBS)
74
+ empty =
75
+ OUTFLAG = -o $(empty)
76
+ COUTFLAG = -o $(empty)
77
+ CSRCFLAG = $(empty)
78
+
79
+ RUBY_EXTCONF_H = unicode_support_version.h
80
+ cflags = $(optflags) $(debugflags) $(warnflags)
81
+ cxxflags = $(optflags) $(debugflags) $(warnflags)
82
+ optflags = -O3
83
+ debugflags = -ggdb3
84
+ warnflags = -Wall -Wextra -Wdeclaration-after-statement -Wdeprecated-declarations -Wduplicated-cond -Wimplicit-function-declaration -Wimplicit-int -Wmisleading-indentation -Wpointer-arith -Wrestrict -Wwrite-strings -Wimplicit-fallthrough=0 -Wmissing-noreturn -Wno-cast-function-type -Wno-constant-logical-operand -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-packed-bitfield-compat -Wno-parentheses-equality -Wno-self-assign -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable
85
+ cppflags =
86
+ CCDLFLAGS = -fPIC
87
+ CFLAGS = $(CCDLFLAGS) $(cflags) $(ARCH_FLAG)
88
+ INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
89
+ DEFS =
90
+ CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\" -I/work/rakhil/ruby_5.1.0/ruby-ibmdb/IBM_DB_Adapter/ibm_db/ext/../lib/clidriver/include $(DEFS) $(cppflags)
91
+ CXXFLAGS = $(CCDLFLAGS) $(cxxflags) $(ARCH_FLAG)
92
+ ldflags = -L. -fstack-protector-strong -rdynamic -Wl,-export-dynamic
93
+ dldflags = -Wl,--compress-debug-sections=zlib
94
+ ARCH_FLAG =
95
+ DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
96
+ LDSHARED = $(CC) -shared
97
+ LDSHAREDXX = $(CXX) -shared
98
+ AR = ar
99
+ EXEEXT =
100
+
101
+ RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
102
+ RUBY_SO_NAME = ruby
103
+ RUBYW_INSTALL_NAME =
104
+ RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
105
+ RUBYW_BASE_NAME = rubyw
106
+ RUBY_BASE_NAME = ruby
107
+
108
+ arch = x86_64-linux
109
+ sitearch = $(arch)
110
+ ruby_version = 2.6.0
111
+ ruby = $(bindir)/$(RUBY_BASE_NAME)
112
+ RUBY = $(ruby)
113
+ ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/backward.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H)
114
+
115
+ RM = rm -f
116
+ RM_RF = $(RUBY) -run -e rm -- -rf
117
+ RMDIRS = rmdir --ignore-fail-on-non-empty -p
118
+ MAKEDIRS = /bin/mkdir -p
119
+ INSTALL = /usr/bin/install -c
120
+ INSTALL_PROG = $(INSTALL) -m 0755
121
+ INSTALL_DATA = $(INSTALL) -m 644
122
+ COPY = cp
123
+ TOUCH = exit >
124
+
125
+ #### End of system configuration section. ####
126
+
127
+ preload =
128
+ libpath = . $(libdir) /work/rakhil/ruby_5.1.0/ruby-ibmdb/IBM_DB_Adapter/ibm_db/ext/../lib/clidriver/lib
129
+ LIBPATH = -L. -L$(libdir) -Wl,-rpath,$(libdir) -L/work/rakhil/ruby_5.1.0/ruby-ibmdb/IBM_DB_Adapter/ibm_db/ext/../lib/clidriver/lib -Wl,-rpath,/work/rakhil/ruby_5.1.0/ruby-ibmdb/IBM_DB_Adapter/ibm_db/ext/../lib/clidriver/lib '-Wl,-R$$ORIGIN/clidriver/lib'
130
+ DEFFILE =
131
+
132
+ CLEANFILES = mkmf.log
133
+ DISTCLEANFILES =
134
+ DISTCLEANDIRS =
135
+
136
+ extout =
137
+ extout_prefix =
138
+ target_prefix =
139
+ LOCAL_LIBS =
140
+ LIBS = -ldb2 -lm -lc
141
+ ORIG_SRCS = ibm_db.c ruby_ibm_db_cli.c
142
+ SRCS = $(ORIG_SRCS)
143
+ OBJS = ibm_db.o ruby_ibm_db_cli.o
144
+ HDRS = $(srcdir)/unicode_support_version.h $(srcdir)/ruby_ibm_db.h $(srcdir)/gil_release_version.h $(srcdir)/ruby_ibm_db_cli.h
145
+ LOCAL_HDRS =
146
+ TARGET = ibm_db
147
+ TARGET_NAME = ibm_db
148
+ TARGET_ENTRY = Init_$(TARGET_NAME)
149
+ DLLIB = $(TARGET).so
150
+ EXTSTATIC =
151
+ STATIC_LIB =
152
+
153
+ TIMESTAMP_DIR = .
154
+ BINDIR = $(bindir)
155
+ RUBYCOMMONDIR = $(sitedir)$(target_prefix)
156
+ RUBYLIBDIR = $(sitelibdir)$(target_prefix)
157
+ RUBYARCHDIR = $(sitearchdir)$(target_prefix)
158
+ HDRDIR = $(rubyhdrdir)/ruby$(target_prefix)
159
+ ARCHHDRDIR = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
160
+ TARGET_SO_DIR =
161
+ TARGET_SO = $(TARGET_SO_DIR)$(DLLIB)
162
+ CLEANLIBS = $(TARGET_SO)
163
+ CLEANOBJS = *.o *.bak
164
+
165
+ all: $(DLLIB)
166
+ static: $(STATIC_LIB)
167
+ .PHONY: all install static install-so install-rb
168
+ .PHONY: clean clean-so clean-static clean-rb
169
+
170
+ clean-static::
171
+ clean-rb-default::
172
+ clean-rb::
173
+ clean-so::
174
+ clean: clean-so clean-static clean-rb-default clean-rb
175
+ -$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
176
+
177
+ distclean-rb-default::
178
+ distclean-rb::
179
+ distclean-so::
180
+ distclean-static::
181
+ distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
182
+ -$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
183
+ -$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
184
+ -$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
185
+
186
+ realclean: distclean
187
+ install: install-so install-rb
188
+
189
+ install-so: $(DLLIB) $(TIMESTAMP_DIR)/.sitearchdir.time
190
+ $(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
191
+ clean-static::
192
+ -$(Q)$(RM) $(STATIC_LIB)
193
+ install-rb: pre-install-rb do-install-rb install-rb-default
194
+ install-rb-default: pre-install-rb-default do-install-rb-default
195
+ pre-install-rb: Makefile
196
+ pre-install-rb-default: Makefile
197
+ do-install-rb:
198
+ do-install-rb-default:
199
+ pre-install-rb-default:
200
+ @$(NULLCMD)
201
+ $(TIMESTAMP_DIR)/.sitearchdir.time:
202
+ $(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
203
+ $(Q) $(TOUCH) $@
204
+
205
+ site-install: site-install-so site-install-rb
206
+ site-install-so: install-so
207
+ site-install-rb: install-rb
208
+
209
+ .SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
210
+
211
+ .cc.o:
212
+ $(ECHO) compiling $(<)
213
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
214
+
215
+ .cc.S:
216
+ $(ECHO) translating $(<)
217
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
218
+
219
+ .mm.o:
220
+ $(ECHO) compiling $(<)
221
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
222
+
223
+ .mm.S:
224
+ $(ECHO) translating $(<)
225
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
226
+
227
+ .cxx.o:
228
+ $(ECHO) compiling $(<)
229
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
230
+
231
+ .cxx.S:
232
+ $(ECHO) translating $(<)
233
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
234
+
235
+ .cpp.o:
236
+ $(ECHO) compiling $(<)
237
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
238
+
239
+ .cpp.S:
240
+ $(ECHO) translating $(<)
241
+ $(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
242
+
243
+ .c.o:
244
+ $(ECHO) compiling $(<)
245
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
246
+
247
+ .c.S:
248
+ $(ECHO) translating $(<)
249
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
250
+
251
+ .m.o:
252
+ $(ECHO) compiling $(<)
253
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
254
+
255
+ .m.S:
256
+ $(ECHO) translating $(<)
257
+ $(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
258
+
259
+ $(TARGET_SO): $(OBJS) Makefile
260
+ $(ECHO) linking shared-object $(DLLIB)
261
+ -$(Q)$(RM) $(@)
262
+ $(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
263
+
264
+
265
+
266
+ $(OBJS): $(HDRS) $(ruby_headers)
data/ext/Makefile.nt32.191 CHANGED
@@ -45,7 +45,7 @@ LIBRUBYARG_STATIC = $(LIBRUBY_A)
45
45
  OUTFLAG = -Fe
46
46
  COUTFLAG = -Fo
47
47
 
48
- RUBY_EXTCONF_H = unicode_support_version
48
+ RUBY_EXTCONF_H = unicode_support_version.h
49
49
  cflags =
50
50
  optflags =
51
51
  debugflags =
data/ext/extconf.rb CHANGED
@@ -3,6 +3,7 @@ require 'net/http'
3
3
  require 'open-uri'
4
4
  require 'rubygems/package'
5
5
  require 'zlib'
6
+ require 'zip'
6
7
  require 'fileutils'
7
8
 
8
9
 
@@ -42,6 +43,7 @@ module Kernel
42
43
  end
43
44
 
44
45
  DOWNLOADLINK = ''
46
+ ZIP = false
45
47
 
46
48
  if(RUBY_PLATFORM =~ /aix/i)
47
49
  #AIX
@@ -94,6 +96,15 @@ elsif (RUBY_PLATFORM =~ /darwin/i)
94
96
  else
95
97
  puts "Mac OS 32 bit not supported. Please use an x64 architecture."
96
98
  end
99
+ elsif (RUBY_PLATFORM =~ /mswin/ || RUBY_PLATFORM =~ /mingw/)
100
+ ZIP = true
101
+ if(is64Bit)
102
+ puts "Detected platform - windows 64"
103
+ DOWNLOADLINK= "http://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/ntx64_odbc_cli.zip"
104
+ else
105
+ puts "Detected platform - windows 32"
106
+ DOWNLOADLINK= "http://public.dhe.ibm.com/ibmdl/export/pub/software/data/db2/drivers/odbc_cli/nt32_odbc_cli.zip"
107
+ end
97
108
  end
98
109
 
99
110
  def downloadCLIPackage(destination, link = nil)
@@ -104,7 +115,11 @@ def downloadCLIPackage(destination, link = nil)
104
115
  end
105
116
 
106
117
  uri = URI.parse(downloadLink)
107
- filename = "#{destination}/clidriver.tar.gz"
118
+ if ZIP
119
+ filename = "#{destination}/clidriver.zip"
120
+ else
121
+ filename = "#{destination}/clidriver.tar.gz"
122
+ end
108
123
 
109
124
  headers = {
110
125
  'Accept-Encoding' => 'identity',
@@ -121,6 +136,18 @@ def downloadCLIPackage(destination, link = nil)
121
136
  filename
122
137
  end
123
138
 
139
+ def extract_zip(file, destination)
140
+ FileUtils.mkdir_p(destination)
141
+
142
+ Zip::File.open(file) do |zip_file|
143
+ zip_file.each do |f|
144
+ fpath = File.join(destination, f.name)
145
+ FileUtils.mkdir_p(File.dirname(fpath))
146
+ zip_file.extract(f, fpath) unless File.exist?(fpath)
147
+ end
148
+ end
149
+ end
150
+
124
151
  def untarCLIPackage(archive,destination)
125
152
  Gem::Package::TarReader.new( Zlib::GzipReader.open(archive) ) do |tar|
126
153
  tar.each do |entry|
@@ -157,8 +184,12 @@ if(IBM_DB_HOME == nil || IBM_DB_HOME == '')
157
184
  puts "Environment variable IBM_DB_HOME is not set. Downloading and setting up the DB2 client driver\n"
158
185
  destination = "#{File.expand_path(File.dirname(File.dirname(__FILE__)))}/../lib"
159
186
 
160
- archive = downloadCLIPackage(destination)
161
- untarCLIPackage(archive,destination)
187
+ archive = downloadCLIPackage(destination)
188
+ if (ZIP)
189
+ extract_zip(archive, destination)
190
+ else
191
+ untarCLIPackage(archive,destination)
192
+ end
162
193
 
163
194
  IBM_DB_HOME="#{destination}/clidriver"
164
195
 
@@ -212,8 +243,8 @@ def crash(str)
212
243
  end
213
244
 
214
245
  if( RUBY_VERSION =~ /1.9/ || RUBY_VERSION =~ /2./)
215
- create_header('gil_release_version')
216
- create_header('unicode_support_version')
246
+ create_header('gil_release_version.h')
247
+ create_header('unicode_support_version.h')
217
248
  end
218
249
 
219
250
  unless (have_library(WIN ? 'db2cli' : 'db2','SQLConnect') or find_library(WIN ? 'db2cli' : 'db2','SQLConnect', IBM_DB_LIB))
@@ -285,7 +316,7 @@ def libpathflag(libpath)
285
316
  end
286
317
  end
287
318
 
288
- have_header('gil_release_version')
289
- have_header('unicode_support_version')
319
+ have_header('gil_release_version.h')
320
+ have_header('unicode_support_version.h')
290
321
 
291
322
  create_makefile('ibm_db')
data/ext/gil_release_version.h ADDED
@@ -0,0 +1,3 @@
1
+ #ifndef GIL_RELEASE_VERSION_H
2
+ #define GIL_RELEASE_VERSION_H
3
+ #endif
data/ext/ibm_db.c CHANGED
@@ -20,7 +20,7 @@
20
20
 
21
21
  #include "ruby.h"
22
22
 
23
- #ifdef UNICODE_SUPPORT_VERSION
23
+ #ifdef UNICODE_SUPPORT_VERSION_H
24
24
  #include "ruby/encoding.h"
25
25
  #endif
26
26
 
@@ -119,7 +119,7 @@ static VALUE id_id2name;
119
119
 
120
120
 
121
121
 
122
- #ifdef UNICODE_SUPPORT_VERSION
122
+ #ifdef UNICODE_SUPPORT_VERSION_H
123
123
  const int _check_i = 1;
124
124
  #define arch_is_bigendian() ( (*(char*)&_check_i) == 0 ) /* returns 0 if the machine is of little endian architecture, 1 if the machine is of bigendian architecture*/
125
125
 
@@ -414,7 +414,7 @@ char *estrdup(char *data) {
414
414
  return dup;
415
415
  }
416
416
 
417
- #ifdef UNICODE_SUPPORT_VERSION
417
+ #ifdef UNICODE_SUPPORT_VERSION_H
418
418
  SQLWCHAR *esqlwchardup(SQLWCHAR *data, int len) {
419
419
  SQLWCHAR *dup = ALLOC_N(SQLWCHAR, len + 1 );
420
420
  memset(dup, '\0', (len * sizeof(SQLWCHAR)) + 2 );
@@ -435,7 +435,7 @@ char *estrndup(char *data, int max) {
435
435
  }
436
436
 
437
437
  void strtolower(char *data, int max) {
438
- #ifdef UNICODE_SUPPORT_VERSION
438
+ #ifdef UNICODE_SUPPORT_VERSION_H
439
439
  rb_encoding *enc;
440
440
 
441
441
  if ( arch_is_bigendian() ){
@@ -447,7 +447,7 @@ void strtolower(char *data, int max) {
447
447
 
448
448
  if( max > 0 ) {
449
449
  while (max--) {
450
- #ifdef UNICODE_SUPPORT_VERSION
450
+ #ifdef UNICODE_SUPPORT_VERSION_H
451
451
  data[max] = rb_enc_tolower((int)data[max], enc);
452
452
  #else
453
453
  data[max] = tolower(data[max]);
@@ -457,7 +457,7 @@ void strtolower(char *data, int max) {
457
457
  }
458
458
 
459
459
  void strtoupper(char *data, int max) {
460
- #ifdef UNICODE_SUPPORT_VERSION
460
+ #ifdef UNICODE_SUPPORT_VERSION_H
461
461
  rb_encoding *enc;
462
462
 
463
463
  if ( arch_is_bigendian() ){
@@ -468,7 +468,7 @@ void strtoupper(char *data, int max) {
468
468
  #endif
469
469
  if( max > 0 ) {
470
470
  while (max--) {
471
- #ifdef UNICODE_SUPPORT_VERSION
471
+ #ifdef UNICODE_SUPPORT_VERSION_H
472
472
  data[max] = rb_enc_toupper((int)data[max], enc);
473
473
  #else
474
474
  data[max] = toupper(data[max]);
@@ -687,10 +687,9 @@ static void _ruby_ibm_db_mark_stmt_struct(stmt_handle *handle)
687
687
 
688
688
  VALUE ibm_Ruby_Thread_Call(rb_blocking_function_t *func, void *data1, rb_unblock_function_t *ubf, void *data2)
689
689
  {
690
- #ifdef RUBY_API_VERSION_MAJOR
690
+ #ifdef RUBY_API_VERSION_MAJOR
691
691
  if( RUBY_API_VERSION_MAJOR >=2 && RUBY_API_VERSION_MINOR >=2)
692
- {
693
-
692
+ {
694
693
  #ifdef _WIN32
695
694
  void *(*f)(void*) = (void *(*)(void*))func;
696
695
  return (VALUE)rb_thread_call_without_gvl(f, data1, ubf, data2);
@@ -698,7 +697,7 @@ VALUE ibm_Ruby_Thread_Call(rb_blocking_function_t *func, void *data1, rb_unblock
698
697
  return rb_thread_call_without_gvl(func, data1, ubf, data2);
699
698
  #else
700
699
  rb_thread_call_without_gvl(func, data1, ubf, data2);
701
- #endif
700
+ #endif
702
701
  }
703
702
  else
704
703
  {
@@ -706,7 +705,7 @@ VALUE ibm_Ruby_Thread_Call(rb_blocking_function_t *func, void *data1, rb_unblock
706
705
  }
707
706
  #else
708
707
  rb_thread_call_without_gvl(func, data1, ubf, data2);
709
- #endif
708
+ #endif
710
709
  }
711
710
 
712
711
 
@@ -739,7 +738,7 @@ static void _ruby_ibm_db_free_stmt_handle_and_resources(stmt_handle *handle)
739
738
 
740
739
  /* static _ruby_ibm_db_free_stmt_struct */
741
740
  static void _ruby_ibm_db_free_stmt_struct(stmt_handle *handle)
742
- {
741
+ {
743
742
  if ( handle != NULL ) {
744
743
  _ruby_ibm_db_free_stmt_handle_and_resources( handle );
745
744
  ruby_xfree( handle );
@@ -969,7 +968,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
969
968
  SQLSMALLINT length;
970
969
  SQLSMALLINT to_decrement = 0;
971
970
 
972
- #ifdef UNICODE_SUPPORT_VERSION
971
+ #ifdef UNICODE_SUPPORT_VERSION_H
973
972
  VALUE print_str = Qnil;
974
973
  #else
975
974
  char* print_str = NULL;
@@ -988,7 +987,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
988
987
  stmt_res = (stmt_handle *) conn_or_stmt;
989
988
  }
990
989
 
991
- #ifdef UNICODE_SUPPORT_VERSION
990
+ #ifdef UNICODE_SUPPORT_VERSION_H
992
991
  errMsg = ALLOC_N( SQLWCHAR, DB2_MAX_ERR_MSG_LEN );
993
992
  memset(errMsg, '\0', DB2_MAX_ERR_MSG_LEN * sizeof(SQLWCHAR) );
994
993
 
@@ -1025,9 +1024,9 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1025
1024
 
1026
1025
  if( release_gil == 1 ){
1027
1026
 
1028
- #ifdef UNICODE_SUPPORT_VERSION
1027
+ #ifdef UNICODE_SUPPORT_VERSION_H
1029
1028
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLGetDiagRec_helper, get_DiagRec_args,
1030
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
1029
+ RUBY_UBF_IO, NULL);
1031
1030
  return_code =get_DiagRec_args->return_code;
1032
1031
  #else
1033
1032
  return_code = _ruby_ibm_db_SQLGetDiagRec_helper( get_DiagRec_args );
@@ -1045,7 +1044,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1045
1044
 
1046
1045
  if ( return_code == SQL_SUCCESS) {
1047
1046
 
1048
- #ifdef UNICODE_SUPPORT_VERSION
1047
+ #ifdef UNICODE_SUPPORT_VERSION_H
1049
1048
  while ((p = memchr( (char *)msg, '\n', length * sizeof(SQLWCHAR) ))) {
1050
1049
  to_decrement = 1;
1051
1050
  *p = '\0';
@@ -1087,7 +1086,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1087
1086
  This copying into global should be removed once the deprecated methods
1088
1087
  conn_errormsg and conn_error are removed
1089
1088
  */
1090
- #ifdef UNICODE_SUPPORT_VERSION
1089
+ #ifdef UNICODE_SUPPORT_VERSION_H
1091
1090
  memset(IBM_DB_G( __ruby_conn_err_msg), '\0', DB2_MAX_ERR_MSG_LEN * sizeof(SQLWCHAR) );
1092
1091
  memset(IBM_DB_G( __ruby_conn_err_state), '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
1093
1092
 
@@ -1107,7 +1106,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1107
1106
  conn_res->errorType = 1;
1108
1107
 
1109
1108
  if( conn_res->ruby_error_state == NULL ) {
1110
- #ifdef UNICODE_SUPPORT_VERSION
1109
+ #ifdef UNICODE_SUPPORT_VERSION_H
1111
1110
  conn_res->ruby_error_state = ALLOC_N( SQLWCHAR, SQL_SQLSTATE_SIZE + 1 );
1112
1111
  #else
1113
1112
  conn_res->ruby_error_state = ALLOC_N( char, SQL_SQLSTATE_SIZE + 1 );
@@ -1115,14 +1114,14 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1115
1114
  }
1116
1115
 
1117
1116
  if( conn_res->ruby_error_msg == NULL ) {
1118
- #ifdef UNICODE_SUPPORT_VERSION
1117
+ #ifdef UNICODE_SUPPORT_VERSION_H
1119
1118
  conn_res->ruby_error_msg = ALLOC_N( SQLWCHAR, DB2_MAX_ERR_MSG_LEN + 1 );
1120
1119
  #else
1121
1120
  conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN + 1 );
1122
1121
  #endif
1123
1122
  }
1124
1123
 
1125
- #ifdef UNICODE_SUPPORT_VERSION
1124
+ #ifdef UNICODE_SUPPORT_VERSION_H
1126
1125
  memset( conn_res->ruby_error_state, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
1127
1126
  memset( conn_res->ruby_error_msg, '\0', (DB2_MAX_ERR_MSG_LEN + 1) * sizeof(SQLWCHAR) );
1128
1127
 
@@ -1148,7 +1147,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1148
1147
  conn_res->errorType = 0;
1149
1148
 
1150
1149
  if( conn_res->ruby_error_state == NULL ) {
1151
- #ifdef UNICODE_SUPPORT_VERSION
1150
+ #ifdef UNICODE_SUPPORT_VERSION_H
1152
1151
  conn_res->ruby_error_state = ALLOC_N( SQLWCHAR, SQL_SQLSTATE_SIZE + 1 );
1153
1152
  #else
1154
1153
  conn_res->ruby_error_state = ALLOC_N(char, SQL_SQLSTATE_SIZE + 1 );
@@ -1156,14 +1155,14 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1156
1155
  }
1157
1156
 
1158
1157
  if( conn_res->ruby_error_msg == NULL ) {
1159
- #ifdef UNICODE_SUPPORT_VERSION
1158
+ #ifdef UNICODE_SUPPORT_VERSION_H
1160
1159
  conn_res->ruby_error_msg = ALLOC_N( SQLWCHAR, DB2_MAX_ERR_MSG_LEN + 1 );
1161
1160
  #else
1162
1161
  conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN + 1 );
1163
1162
  #endif
1164
1163
  }
1165
1164
 
1166
- #ifdef UNICODE_SUPPORT_VERSION
1165
+ #ifdef UNICODE_SUPPORT_VERSION_H
1167
1166
  memset( conn_res->ruby_error_state, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
1168
1167
  memset( conn_res->ruby_error_msg, '\0', (DB2_MAX_ERR_MSG_LEN + 1) * sizeof(SQLWCHAR) );
1169
1168
 
@@ -1186,7 +1185,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1186
1185
  }
1187
1186
 
1188
1187
  if( stmt_res->ruby_stmt_err_state == NULL ) {
1189
- #ifdef UNICODE_SUPPORT_VERSION
1188
+ #ifdef UNICODE_SUPPORT_VERSION_H
1190
1189
  stmt_res->ruby_stmt_err_state = ALLOC_N( SQLWCHAR, SQL_SQLSTATE_SIZE + 1 );
1191
1190
  #else
1192
1191
  stmt_res->ruby_stmt_err_state = ALLOC_N( char, SQL_SQLSTATE_SIZE + 1 );
@@ -1194,14 +1193,14 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1194
1193
  }
1195
1194
 
1196
1195
  if( stmt_res->ruby_stmt_err_msg == NULL ) {
1197
- #ifdef UNICODE_SUPPORT_VERSION
1196
+ #ifdef UNICODE_SUPPORT_VERSION_H
1198
1197
  stmt_res->ruby_stmt_err_msg = ALLOC_N( SQLWCHAR, DB2_MAX_ERR_MSG_LEN + 1 );
1199
1198
  #else
1200
1199
  stmt_res->ruby_stmt_err_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN + 1 );
1201
1200
  #endif
1202
1201
  }
1203
1202
 
1204
- #ifdef UNICODE_SUPPORT_VERSION
1203
+ #ifdef UNICODE_SUPPORT_VERSION_H
1205
1204
  memset( stmt_res->ruby_stmt_err_state, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
1206
1205
  memset( stmt_res->ruby_stmt_err_msg, '\0', (DB2_MAX_ERR_MSG_LEN + 1) * sizeof(SQLWCHAR) );
1207
1206
 
@@ -1224,7 +1223,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1224
1223
  This copying into global should be removed once the deprecated methods
1225
1224
  conn_errormsg and conn_error are removed
1226
1225
  */
1227
- #ifdef UNICODE_SUPPORT_VERSION
1226
+ #ifdef UNICODE_SUPPORT_VERSION_H
1228
1227
  memset( IBM_DB_G(__ruby_stmt_err_state), '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
1229
1228
  memset( IBM_DB_G(__ruby_stmt_err_msg), '\0', (DB2_MAX_ERR_MSG_LEN + 1) * sizeof(SQLWCHAR) );
1230
1229
 
@@ -1248,7 +1247,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1248
1247
  switch (API) {
1249
1248
  case DB_ERR_STATE:
1250
1249
  if ( ret_str != NULL ) {
1251
- #ifdef UNICODE_SUPPORT_VERSION
1250
+ #ifdef UNICODE_SUPPORT_VERSION_H
1252
1251
  memcpy( ret_str, sqlstate, (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
1253
1252
  if( ret_str_len != NULL ) {
1254
1253
  *ret_str_len = (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR);
@@ -1263,7 +1262,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
1263
1262
  break;
1264
1263
  case DB_ERRMSG:
1265
1264
  if ( ret_str != NULL ) {
1266
- #ifdef UNICODE_SUPPORT_VERSION
1265
+ #ifdef UNICODE_SUPPORT_VERSION_H
1267
1266
  memcpy( ret_str, msg, length );
1268
1267
  #else
1269
1268
  memcpy( ret_str, msg, length );
@@ -1311,7 +1310,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1311
1310
 
1312
1311
  set_handle_attr_args *handleAttr_args = NULL;
1313
1312
 
1314
- #ifdef UNICODE_SUPPORT_VERSION
1313
+ #ifdef UNICODE_SUPPORT_VERSION_H
1315
1314
  VALUE data_utf16 = Qnil;
1316
1315
  #endif
1317
1316
 
@@ -1330,7 +1329,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1330
1329
  ((stmt_handle*)handle)->s_case_mode = CASE_NATURAL;
1331
1330
  break;
1332
1331
  default:
1333
- #ifdef UNICODE_SUPPORT_VERSION
1332
+ #ifdef UNICODE_SUPPORT_VERSION_H
1334
1333
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
1335
1334
  #else
1336
1335
  *error = rb_str_new2("ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
@@ -1349,7 +1348,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1349
1348
  ((conn_handle*)handle)->c_case_mode = CASE_NATURAL;
1350
1349
  break;
1351
1350
  default:
1352
- #ifdef UNICODE_SUPPORT_VERSION
1351
+ #ifdef UNICODE_SUPPORT_VERSION_H
1353
1352
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
1354
1353
  #else
1355
1354
  *error = rb_str_new2("ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
@@ -1357,7 +1356,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1357
1356
  return Qfalse;
1358
1357
  }
1359
1358
  } else {
1360
- #ifdef UNICODE_SUPPORT_VERSION
1359
+ #ifdef UNICODE_SUPPORT_VERSION_H
1361
1360
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Connection or statement handle must be passed in");
1362
1361
  #else
1363
1362
  *error = rb_str_new2("Connection or statement handle must be passed in");
@@ -1373,7 +1372,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1373
1372
 
1374
1373
  if (TYPE(data) == T_STRING) {
1375
1374
 
1376
- #ifndef UNICODE_SUPPORT_VERSION
1375
+ #ifndef UNICODE_SUPPORT_VERSION_H
1377
1376
  option_str = RSTRING_PTR(data);
1378
1377
  #else
1379
1378
  data_utf16 = _ruby_ibm_db_export_str_to_utf16(data);
@@ -1396,7 +1395,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1396
1395
  ruby_xfree( handleAttr_args );
1397
1396
  handleAttr_args = NULL;
1398
1397
  if( handle != NULL && ((stmt_handle *)handle)->ruby_stmt_err_msg != NULL ) {
1399
- #ifdef UNICODE_SUPPORT_VERSION
1398
+ #ifdef UNICODE_SUPPORT_VERSION_H
1400
1399
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Setting of statement attribute failed: "),
1401
1400
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(((stmt_handle *)handle)->ruby_stmt_err_msg,
1402
1401
  ((stmt_handle *)handle)->ruby_stmt_err_msg_len)
@@ -1405,7 +1404,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1405
1404
  *error = rb_str_cat2(rb_str_new2("Setting of statement attribute failed: "), ((stmt_handle *)handle)->ruby_stmt_err_msg);
1406
1405
  #endif
1407
1406
  } else {
1408
- #ifdef UNICODE_SUPPORT_VERSION
1407
+ #ifdef UNICODE_SUPPORT_VERSION_H
1409
1408
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Setting of statement attribute failed: <error message could not be retrieved>");
1410
1409
  #else
1411
1410
  *error = rb_str_new2("Setting of statement attribute failed: <error message could not be retrieved>");
@@ -1438,7 +1437,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1438
1437
  ruby_xfree( handleAttr_args );
1439
1438
  handleAttr_args = NULL;
1440
1439
  if( handle != NULL && ((stmt_handle *)handle)->ruby_stmt_err_msg != NULL ) {
1441
- #ifdef UNICODE_SUPPORT_VERSION
1440
+ #ifdef UNICODE_SUPPORT_VERSION_H
1442
1441
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Setting of statement attribute failed: "),
1443
1442
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(((stmt_handle *)handle)->ruby_stmt_err_msg,
1444
1443
  ((stmt_handle *)handle)->ruby_stmt_err_msg_len)
@@ -1447,7 +1446,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1447
1446
  *error = rb_str_cat2(rb_str_new2("Setting of statement attribute failed: "), ((stmt_handle *)handle)->ruby_stmt_err_msg);
1448
1447
  #endif
1449
1448
  } else {
1450
- #ifdef UNICODE_SUPPORT_VERSION
1449
+ #ifdef UNICODE_SUPPORT_VERSION_H
1451
1450
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Setting of statement attribute failed: <error message could not be retrieved>");
1452
1451
  #else
1453
1452
  *error = rb_str_new2("Setting of statement attribute failed: <error message could not be retrieved>");
@@ -1465,7 +1464,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1465
1464
  handleAttr_args->attribute = opt_key;
1466
1465
 
1467
1466
  if (TYPE(data) == T_STRING) {
1468
- #ifndef UNICODE_SUPPORT_VERSION
1467
+ #ifndef UNICODE_SUPPORT_VERSION_H
1469
1468
  option_str = RSTRING_PTR(data);
1470
1469
  handleAttr_args->strLength = RSTRING_LEN(data);
1471
1470
  #else
@@ -1488,7 +1487,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1488
1487
  ruby_xfree( handleAttr_args );
1489
1488
  handleAttr_args = NULL;
1490
1489
  if( handle != NULL && ((conn_handle *)handle)->ruby_error_msg != NULL ) {
1491
- #ifdef UNICODE_SUPPORT_VERSION
1490
+ #ifdef UNICODE_SUPPORT_VERSION_H
1492
1491
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Setting of connection attribute failed: "),
1493
1492
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(((conn_handle *)handle)->ruby_error_msg,
1494
1493
  ((conn_handle *)handle)->ruby_error_msg_len)
@@ -1497,7 +1496,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1497
1496
  *error = rb_str_cat2(rb_str_new2("Setting of connection attribute failed: "), ((conn_handle *)handle)->ruby_error_msg);
1498
1497
  #endif
1499
1498
  } else {
1500
- #ifdef UNICODE_SUPPORT_VERSION
1499
+ #ifdef UNICODE_SUPPORT_VERSION_H
1501
1500
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Setting of connection attribute failed: <error message could not be retrieved>");
1502
1501
  #else
1503
1502
  *error = rb_str_new2("Setting of connection attribute failed: <error message could not be retrieved>");
@@ -1521,7 +1520,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1521
1520
  ruby_xfree( handleAttr_args );
1522
1521
  handleAttr_args = NULL;
1523
1522
  if( handle != NULL && ((conn_handle *)handle)->ruby_error_msg != NULL ) {
1524
- #ifdef UNICODE_SUPPORT_VERSION
1523
+ #ifdef UNICODE_SUPPORT_VERSION_H
1525
1524
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Setting of connection attribute failed: "),
1526
1525
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( ((stmt_handle *)handle)->ruby_stmt_err_msg,
1527
1526
  ((stmt_handle *)handle)->ruby_stmt_err_msg_len)
@@ -1530,7 +1529,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1530
1529
  *error = rb_str_cat2(rb_str_new2("Setting of connection attribute failed: "), ((conn_handle *)handle)->ruby_error_msg);
1531
1530
  #endif
1532
1531
  } else {
1533
- #ifdef UNICODE_SUPPORT_VERSION
1532
+ #ifdef UNICODE_SUPPORT_VERSION_H
1534
1533
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Setting of connection attribute failed: <error message could not be retrieved>");
1535
1534
  #else
1536
1535
  *error = rb_str_new2("Setting of connection attribute failed: <error message could not be retrieved>");
@@ -1547,7 +1546,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
1547
1546
  }
1548
1547
  }
1549
1548
  } else {
1550
- #ifdef UNICODE_SUPPORT_VERSION
1549
+ #ifdef UNICODE_SUPPORT_VERSION_H
1551
1550
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Connection or statement handle must be passed in");
1552
1551
  #else
1553
1552
  *error = rb_str_new2("Connection or statement handle must be passed in");
@@ -1612,7 +1611,7 @@ static int _ruby_ibm_db_parse_options ( VALUE options, int type, void *handle, V
1612
1611
  static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1613
1612
  {
1614
1613
  int rc = -1, i;
1615
- #ifdef UNICODE_SUPPORT_VERSION
1614
+ #ifdef UNICODE_SUPPORT_VERSION_H
1616
1615
  SQLWCHAR tmp_name[BUFSIZ];
1617
1616
  #else
1618
1617
  SQLCHAR tmp_name[BUFSIZ];
@@ -1653,7 +1652,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1653
1652
  stmt_res->column_info[i].loc_type = 0;
1654
1653
 
1655
1654
  stmt_res->column_info[i].name = tmp_name;
1656
- #ifdef UNICODE_SUPPORT_VERSION
1655
+ #ifdef UNICODE_SUPPORT_VERSION_H
1657
1656
  memset(stmt_res->column_info[i].name, '\0', BUFSIZ * sizeof(SQLWCHAR));
1658
1657
  #else
1659
1658
  memset(stmt_res->column_info[i].name, '\0', BUFSIZ);
@@ -1678,7 +1677,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1678
1677
  return -1;
1679
1678
  }
1680
1679
  if ( describecolargs->name_length <= 0 ) {
1681
- #ifdef UNICODE_SUPPORT_VERSION
1680
+ #ifdef UNICODE_SUPPORT_VERSION_H
1682
1681
  stmt_res->column_info[i].name = esqlwchardup((SQLWCHAR*)"", 0);
1683
1682
  stmt_res->column_info[i].name_length = 0;
1684
1683
  #else
@@ -1687,7 +1686,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1687
1686
  } else if ( describecolargs->name_length >= BUFSIZ ) {
1688
1687
  /* column name is longer than BUFSIZ, free the previously allocate memory and reallocate new*/
1689
1688
 
1690
- #ifdef UNICODE_SUPPORT_VERSION
1689
+ #ifdef UNICODE_SUPPORT_VERSION_H
1691
1690
  stmt_res->column_info[i].name = (SQLWCHAR*)ALLOC_N(SQLWCHAR, describecolargs->name_length+1);
1692
1691
  stmt_res->column_info[i].name_length = describecolargs->name_length ;
1693
1692
  #else
@@ -1711,7 +1710,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
1711
1710
  return -1;
1712
1711
  }
1713
1712
  } else {
1714
- #ifdef UNICODE_SUPPORT_VERSION
1713
+ #ifdef UNICODE_SUPPORT_VERSION_H
1715
1714
  stmt_res->column_info[i].name = (SQLWCHAR*) esqlwchardup( tmp_name, describecolargs->name_length );
1716
1715
  stmt_res->column_info[i].name_length = describecolargs->name_length;
1717
1716
  #else
@@ -1771,7 +1770,7 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
1771
1770
  case SQL_LONGVARCHAR:
1772
1771
  case SQL_WLONGVARCHAR:
1773
1772
 
1774
- #ifdef UNICODE_SUPPORT_VERSION
1773
+ #ifdef UNICODE_SUPPORT_VERSION_H
1775
1774
  bindCol_args->TargetType = SQL_C_WCHAR;
1776
1775
  bindCol_args->buff_length = (stmt_res->column_info[i].size+1) * sizeof(SQLWCHAR);
1777
1776
  row_data->str_val = ALLOC_N(char, bindCol_args->buff_length);
@@ -2002,7 +2001,6 @@ static void _ruby_ibm_db_clear_stmt_err_cache()
2002
2001
  /* static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data )
2003
2002
  */
2004
2003
  static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2005
-
2006
2004
  SQLINTEGER conn_alive;
2007
2005
  SQLINTEGER enable_numeric_literals = 1; /* Enable CLI numeric literals */
2008
2006
 
@@ -2017,7 +2015,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2017
2015
  int reused = 0;
2018
2016
  SQLSMALLINT out_length = 0;
2019
2017
  VALUE entry = Qnil;
2020
- #ifdef UNICODE_SUPPORT_VERSION
2018
+ #ifdef UNICODE_SUPPORT_VERSION_H
2021
2019
  SQLWCHAR *server = NULL;
2022
2020
  VALUE iserver = Qnil;
2023
2021
  VALUE idsserver = Qnil;
@@ -2089,7 +2087,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2089
2087
  ruby_xfree( handleAttr_args );
2090
2088
  handleAttr_args = NULL;
2091
2089
  if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
2092
- #ifdef UNICODE_SUPPORT_VERSION
2090
+ #ifdef UNICODE_SUPPORT_VERSION_H
2093
2091
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Allocation of environment handle failed: "),
2094
2092
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(conn_res->ruby_error_msg, conn_res->ruby_error_msg_len )
2095
2093
  );
@@ -2097,7 +2095,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2097
2095
  *error = rb_str_cat2(rb_str_new2("Allocation of environment handle failed: "), conn_res->ruby_error_msg);
2098
2096
  #endif
2099
2097
  } else {
2100
- #ifdef UNICODE_SUPPORT_VERSION
2098
+ #ifdef UNICODE_SUPPORT_VERSION_H
2101
2099
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Allocation of environment handle failed: <error message could not be retrieved>");
2102
2100
  #else
2103
2101
  *error = rb_str_new2("Allocation of environment handle failed: <error message could not be retrieved>");
@@ -2121,7 +2119,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2121
2119
  if (rc != SQL_SUCCESS) {
2122
2120
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->henv, SQL_HANDLE_ENV, rc, 1, NULL, NULL, -1, 1, 0 );
2123
2121
  if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
2124
- #ifdef UNICODE_SUPPORT_VERSION
2122
+ #ifdef UNICODE_SUPPORT_VERSION_H
2125
2123
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Setting of Environemnt Attribute during connection failed: "),
2126
2124
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(conn_res->ruby_error_msg, conn_res->ruby_error_msg_len )
2127
2125
  );
@@ -2129,7 +2127,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2129
2127
  *error = rb_str_cat2(rb_str_new2("Setting of Environemnt Attribute during connection failed: "),conn_res->ruby_error_msg);
2130
2128
  #endif
2131
2129
  } else {
2132
- #ifdef UNICODE_SUPPORT_VERSION
2130
+ #ifdef UNICODE_SUPPORT_VERSION_H
2133
2131
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Setting of Environemnt Attribute during connection failed: <error message could not be retrieved>");
2134
2132
  #else
2135
2133
  *error = rb_str_new2("Setting of Environemnt Attribute during connection failed: <error message could not be retrieved>");
@@ -2149,14 +2147,14 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2149
2147
  if (rc != SQL_SUCCESS) {
2150
2148
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->henv, SQL_HANDLE_ENV, rc, 1, NULL, NULL, -1, 1, 0 );
2151
2149
  if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
2152
- #ifdef UNICODE_SUPPORT_VERSION
2150
+ #ifdef UNICODE_SUPPORT_VERSION_H
2153
2151
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Allocation of connection handle failed: "),
2154
2152
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( conn_res->ruby_error_msg, conn_res->ruby_error_msg_len) );
2155
2153
  #else
2156
2154
  *error = rb_str_cat2(rb_str_new2("Allocation of connection handle failed: "),conn_res->ruby_error_msg);
2157
2155
  #endif
2158
2156
  } else {
2159
- #ifdef UNICODE_SUPPORT_VERSION
2157
+ #ifdef UNICODE_SUPPORT_VERSION_H
2160
2158
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Allocation of connection handle failed: <error message could not be retrieved>");
2161
2159
  #else
2162
2160
  *error = rb_str_new2("Allocation of connection handle failed: <error message could not be retrieved>");
@@ -2232,14 +2230,14 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2232
2230
  SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc );
2233
2231
  SQLFreeHandle( SQL_HANDLE_ENV, conn_res->henv );
2234
2232
  if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
2235
- #ifdef UNICODE_SUPPORT_VERSION
2233
+ #ifdef UNICODE_SUPPORT_VERSION_H
2236
2234
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Connection failed: "),
2237
2235
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(conn_res->ruby_error_msg, conn_res->ruby_error_msg_len));
2238
2236
  #else
2239
2237
  *error = rb_str_cat2(rb_str_new2("Connection failed: "),conn_res->ruby_error_msg);
2240
2238
  #endif
2241
2239
  } else {
2242
- #ifdef UNICODE_SUPPORT_VERSION
2240
+ #ifdef UNICODE_SUPPORT_VERSION_H
2243
2241
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Connection failed: <error message could not be retrieved>");
2244
2242
  #else
2245
2243
  *error = rb_str_new2("Connection failed: <error message could not be retrieved>");
@@ -2268,14 +2266,14 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2268
2266
  SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc );
2269
2267
  SQLFreeHandle( SQL_HANDLE_ENV, conn_res->henv );
2270
2268
  if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
2271
- #ifdef UNICODE_SUPPORT_VERSION
2269
+ #ifdef UNICODE_SUPPORT_VERSION_H
2272
2270
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Failed to retrieve autocommit status during connection: "),
2273
2271
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(conn_res->ruby_error_msg, conn_res->ruby_error_msg_len));
2274
2272
  #else
2275
2273
  *error = rb_str_cat2(rb_str_new2("Connection failed: "),conn_res->ruby_error_msg);
2276
2274
  #endif
2277
2275
  } else {
2278
- #ifdef UNICODE_SUPPORT_VERSION
2276
+ #ifdef UNICODE_SUPPORT_VERSION_H
2279
2277
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Failed to retrieve autocommit status during connection: <error message could not be retrieved>");
2280
2278
  #else
2281
2279
  *error = rb_str_new2("Connection failed: <error message could not be retrieved>");
@@ -2299,7 +2297,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2299
2297
  #endif
2300
2298
  #endif
2301
2299
  /* Get the server name */
2302
- #ifdef UNICODE_SUPPORT_VERSION
2300
+ #ifdef UNICODE_SUPPORT_VERSION_H
2303
2301
  server = ALLOC_N(SQLWCHAR, 2048);
2304
2302
  memset(server, 0, sizeof(server));
2305
2303
  iserver = _ruby_ibm_db_export_char_to_utf16_rstr("AS");
@@ -2315,14 +2313,14 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
2315
2313
  getInfo_args->infoType = SQL_DBMS_NAME;
2316
2314
  getInfo_args->infoValue = (SQLPOINTER)server;
2317
2315
 
2318
- #ifdef UNICODE_SUPPORT_VERSION
2316
+ #ifdef UNICODE_SUPPORT_VERSION_H
2319
2317
  getInfo_args->buff_length = 2048 * sizeof(SQLWCHAR);
2320
2318
  #else
2321
2319
  getInfo_args->buff_length = 2048;
2322
2320
  #endif
2323
2321
  rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
2324
2322
 
2325
- #ifndef UNICODE_SUPPORT_VERSION
2323
+ #ifndef UNICODE_SUPPORT_VERSION_H
2326
2324
  if (!strcmp((char *)server, "AS")) {
2327
2325
  is_systemi = 1;
2328
2326
  }
@@ -2445,7 +2443,7 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2445
2443
  VALUE r_db, r_uid, r_passwd, options,return_value;
2446
2444
  VALUE r_literal_replacement = Qnil;
2447
2445
 
2448
- #ifdef UNICODE_SUPPORT_VERSION
2446
+ #ifdef UNICODE_SUPPORT_VERSION_H
2449
2447
  VALUE r_db_utf16, r_uid_utf16, r_passwd_utf16, r_db_ascii;
2450
2448
  #endif
2451
2449
 
@@ -2459,7 +2457,7 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2459
2457
  conn_args = ALLOC( connect_args );
2460
2458
  memset(conn_args,'\0',sizeof(struct _ibm_db_connect_args_struct));
2461
2459
 
2462
- #ifndef UNICODE_SUPPORT_VERSION
2460
+ #ifndef UNICODE_SUPPORT_VERSION_H
2463
2461
  conn_args->database = (SQLCHAR *) RSTRING_PTR( r_db );
2464
2462
  conn_args->database_len = (SQLSMALLINT) RSTRING_LEN( r_db );
2465
2463
 
@@ -2486,7 +2484,7 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2486
2484
  #endif
2487
2485
 
2488
2486
  /* If the string contains a =, set ctlg_conn = 0, to use SQLDriverConnect */
2489
- #ifndef UNICODE_SUPPORT_VERSION
2487
+ #ifndef UNICODE_SUPPORT_VERSION_H
2490
2488
  if ( strstr( (char *) conn_args->database, "=") != NULL ) {
2491
2489
  #else
2492
2490
  if ( RARRAY_LEN(rb_str_split(r_db_ascii,"=")) > 1) { /*There is no direct API like strstr, hence split string with delimiter as '=' if the returned RARRAY has more than 1 element then set ctlg_conn = 0*/
@@ -2508,7 +2506,7 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2508
2506
 
2509
2507
  if( isPersistent ) {
2510
2508
  /*If making a persistent connection calculate the hash key to cache the connection in persistence list*/
2511
- #ifndef UNICODE_SUPPORT_VERSION
2509
+ #ifndef UNICODE_SUPPORT_VERSION_H
2512
2510
  helper_args->hKey = rb_str_concat(rb_str_dup(r_uid), r_db); /*A duplicate of r_uid is made so that initial value is intact*/
2513
2511
  helper_args->hKey = rb_str_concat(helper_args->hKey, r_passwd);
2514
2512
  helper_args->hKey = rb_str_concat(rb_str_new2("__ibm_db_"),helper_args->hKey);
@@ -2526,9 +2524,8 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2526
2524
  helper_args->literal_replacement = SET_QUOTED_LITERAL_REPLACEMENT_ON; /*QUOTED LITERAL replacemnt is ON by default*/
2527
2525
  }
2528
2526
  /* Call the function where the actual logic is being run*/
2529
- #ifdef UNICODE_SUPPORT_VERSION
2530
-
2531
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_connect_helper2, helper_args, (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
2527
+ #ifdef UNICODE_SUPPORT_VERSION_H
2528
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_connect_helper2, helper_args, RUBY_UBF_IO, NULL);
2532
2529
 
2533
2530
 
2534
2531
  conn_res = helper_args->conn_res;
@@ -2555,9 +2552,9 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
2555
2552
  return_value = Data_Wrap_Struct(le_conn_struct, _ruby_ibm_db_mark_conn_struct, _ruby_ibm_db_free_conn_struct, conn_res);
2556
2553
  }
2557
2554
  }
2558
- #else
2555
+ #else
2559
2556
  return_value = _ruby_ibm_db_connect_helper2( helper_args );
2560
- #endif
2557
+ #endif
2561
2558
  /* Free the memory allocated */
2562
2559
  if(conn_args != NULL) {
2563
2560
  /* Memory to structure elements of helper_args is not allocated explicitly hence it is automatically freed by Ruby.
@@ -2596,7 +2593,7 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(_rounding_mode
2596
2593
  exec_cum_prepare_args *exec_direct_args = NULL;
2597
2594
  bind_col_args *bindCol_args = NULL;
2598
2595
  fetch_data_args *fetch_args = NULL;
2599
- #ifndef UNICODE_SUPPORT_VERSION
2596
+ #ifndef UNICODE_SUPPORT_VERSION_H
2600
2597
  SQLCHAR *stmt = (SQLCHAR *)"values current decfloat rounding mode";
2601
2598
  #else
2602
2599
  VALUE stmt = Qnil;
@@ -2606,7 +2603,7 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(_rounding_mode
2606
2603
  exec_direct_args = ALLOC( exec_cum_prepare_args );
2607
2604
  memset(exec_direct_args,'\0',sizeof(struct _ibm_db_exec_direct_args_struct));
2608
2605
 
2609
- #ifdef UNICODE_SUPPORT_VERSION
2606
+ #ifdef UNICODE_SUPPORT_VERSION_H
2610
2607
  exec_direct_args->stmt_string = (SQLWCHAR *)RSTRING_PTR( stmt );
2611
2608
  #else
2612
2609
  exec_direct_args->stmt_string = stmt;
@@ -2826,10 +2823,8 @@ static void _ruby_ibm_db_clear_conn_err_cache()
2826
2823
  *
2827
2824
  */
2828
2825
  VALUE ibm_db_connect(int argc, VALUE *argv, VALUE self)
2829
- {
2830
-
2826
+ {
2831
2827
  _ruby_ibm_db_clear_conn_err_cache();
2832
-
2833
2828
  return _ruby_ibm_db_connect_helper( argc, argv, 0 );
2834
2829
  }
2835
2830
  /* */
@@ -2902,7 +2897,7 @@ VALUE ruby_ibm_db_createDb_helper(VALUE connection, VALUE dbName, VALUE codeSet,
2902
2897
 
2903
2898
 
2904
2899
  VALUE return_value = Qfalse;
2905
- #ifdef UNICODE_SUPPORT_VERSION
2900
+ #ifdef UNICODE_SUPPORT_VERSION_H
2906
2901
  VALUE dbName_utf16 = Qnil;
2907
2902
  VALUE codeSet_utf16 = Qnil;
2908
2903
  VALUE mode_utf16 = Qnil;
@@ -2930,7 +2925,7 @@ VALUE ruby_ibm_db_createDb_helper(VALUE connection, VALUE dbName, VALUE codeSet,
2930
2925
  create_db_args = ALLOC( create_drop_db_args );
2931
2926
  memset(create_db_args,'\0',sizeof(struct _ibm_db_create_drop_db_args_struct));
2932
2927
 
2933
- #ifdef UNICODE_SUPPORT_VERSION
2928
+ #ifdef UNICODE_SUPPORT_VERSION_H
2934
2929
  dbName_utf16 = _ruby_ibm_db_export_str_to_utf16(dbName);
2935
2930
 
2936
2931
  create_db_args->dbName = (SQLWCHAR*)RSTRING_PTR(dbName_utf16);
@@ -2973,9 +2968,9 @@ VALUE ruby_ibm_db_createDb_helper(VALUE connection, VALUE dbName, VALUE codeSet,
2973
2968
 
2974
2969
  _ruby_ibm_db_clear_conn_err_cache();
2975
2970
 
2976
- #ifdef UNICODE_SUPPORT_VERSION
2971
+ #ifdef UNICODE_SUPPORT_VERSION_H
2977
2972
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLCreateDB_helper, create_db_args,
2978
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL );
2973
+ RUBY_UBF_IO, NULL );
2979
2974
  rc = create_db_args->rc;
2980
2975
  #else
2981
2976
  rc = _ruby_ibm_db_SQLCreateDB_helper( create_db_args );
@@ -2988,7 +2983,7 @@ VALUE ruby_ibm_db_createDb_helper(VALUE connection, VALUE dbName, VALUE codeSet,
2988
2983
  if(conn_res->sqlcode == -1005 && 1 == createNX) {
2989
2984
  return_value = Qtrue; /*Return true if database already exists and Create if not existing called*/
2990
2985
  /*Clear the error messages*/
2991
- #ifdef UNICODE_SUPPORT_VERSION
2986
+ #ifdef UNICODE_SUPPORT_VERSION_H
2992
2987
  memset( conn_res->ruby_error_state, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
2993
2988
  memset( conn_res->ruby_error_msg, '\0', (DB2_MAX_ERR_MSG_LEN + 1) * sizeof(SQLWCHAR) );
2994
2989
  #else
@@ -3058,7 +3053,7 @@ VALUE ibm_db_createDB(int argc, VALUE *argv, VALUE self)
3058
3053
  * DropDb helper
3059
3054
  */
3060
3055
  VALUE ruby_ibm_db_dropDb_helper(VALUE connection, VALUE dbName) {
3061
- #ifdef UNICODE_SUPPORT_VERSION
3056
+ #ifdef UNICODE_SUPPORT_VERSION_H
3062
3057
  VALUE dbName_utf16 = Qnil;
3063
3058
  #endif
3064
3059
 
@@ -3086,7 +3081,7 @@ VALUE ruby_ibm_db_dropDb_helper(VALUE connection, VALUE dbName) {
3086
3081
  drop_db_args = ALLOC( create_drop_db_args );
3087
3082
  memset(drop_db_args,'\0',sizeof(struct _ibm_db_create_drop_db_args_struct));
3088
3083
 
3089
- #ifdef UNICODE_SUPPORT_VERSION
3084
+ #ifdef UNICODE_SUPPORT_VERSION_H
3090
3085
  dbName_utf16 = _ruby_ibm_db_export_str_to_utf16(dbName);
3091
3086
 
3092
3087
  drop_db_args->dbName = (SQLWCHAR*)RSTRING_PTR(dbName_utf16);
@@ -3103,9 +3098,9 @@ VALUE ruby_ibm_db_dropDb_helper(VALUE connection, VALUE dbName) {
3103
3098
 
3104
3099
  _ruby_ibm_db_clear_conn_err_cache();
3105
3100
 
3106
- #ifdef UNICODE_SUPPORT_VERSION
3101
+ #ifdef UNICODE_SUPPORT_VERSION_H
3107
3102
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDropDB_helper, drop_db_args,
3108
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL );
3103
+ RUBY_UBF_IO, NULL );
3109
3104
  rc = drop_db_args->rc;
3110
3105
  #else
3111
3106
  rc = _ruby_ibm_db_SQLDropDB_helper( drop_db_args );
@@ -3451,7 +3446,7 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3451
3446
 
3452
3447
  int rc = 0;
3453
3448
  VALUE return_value = Qtrue;
3454
- #ifdef UNICODE_SUPPORT_VERSION
3449
+ #ifdef UNICODE_SUPPORT_VERSION_H
3455
3450
  char *err_str = NULL;
3456
3451
  #endif
3457
3452
 
@@ -3460,10 +3455,9 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3460
3455
  /* if argc == 3, then the default value for param_type will be used */
3461
3456
  case 3:
3462
3457
  param_type = SQL_PARAM_INPUT;
3463
-
3464
- #ifdef UNICODE_SUPPORT_VERSION
3465
-
3466
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3458
+
3459
+ #ifdef UNICODE_SUPPORT_VERSIO
3460
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3467
3461
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
3468
3462
  rc = data->rc;
3469
3463
  #else
@@ -3482,10 +3476,9 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3482
3476
  break;
3483
3477
 
3484
3478
  case 4:
3485
-
3486
- #ifdef UNICODE_SUPPORT_VERSION
3479
+ #ifdef UNICODE_SUPPORT_VERSION_H
3487
3480
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3488
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
3481
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3489
3482
  rc = data->rc;
3490
3483
  #else
3491
3484
  rc = _ruby_ibm_db_SQLDescribeParam_helper( data );
@@ -3503,8 +3496,7 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3503
3496
  break;
3504
3497
 
3505
3498
  case 5:
3506
-
3507
- #ifdef UNICODE_SUPPORT_VERSION
3499
+ #ifdef UNICODE_SUPPORT_VERSION_H
3508
3500
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3509
3501
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3510
3502
  rc = data->rc;
@@ -3525,10 +3517,9 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3525
3517
  break;
3526
3518
 
3527
3519
  case 6:
3528
-
3529
- #ifdef UNICODE_SUPPORT_VERSION
3530
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3531
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3520
+ #ifdef UNICODE_SUPPORT_VERSION_H
3521
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDescribeParam_helper, data,
3522
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3532
3523
  rc = data->rc;
3533
3524
  #else
3534
3525
  rc = _ruby_ibm_db_SQLDescribeParam_helper( data );
@@ -3568,7 +3559,7 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
3568
3559
  /* end Switch */
3569
3560
 
3570
3561
  if( rc == SQL_ERROR ) {
3571
- #ifdef UNICODE_SUPPORT_VERSION
3562
+ #ifdef UNICODE_SUPPORT_VERSION_H
3572
3563
  /*String in SQLWCHAR(utf16) format will contain '\0' due to which the err string will be printed wrong,
3573
3564
  * hence convert it to utf8 format
3574
3565
  */
@@ -3656,7 +3647,7 @@ VALUE ibm_db_bind_param(int argc, VALUE *argv, VALUE self)
3656
3647
  rb_scan_args(argc, argv, "35", &stmt, &r_param_no, &r_varname,
3657
3648
  &r_param_type, &r_data_type, &r_precision, &r_scale, &r_size);
3658
3649
 
3659
- #ifdef UNICODE_SUPPORT_VERSION
3650
+ #ifdef UNICODE_SUPPORT_VERSION_H
3660
3651
  varname = RSTRING_PTR(r_varname);
3661
3652
  varname_len = RSTRING_LEN(r_varname);
3662
3653
  #else
@@ -3761,9 +3752,9 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
3761
3752
  end_X_args->handleType = SQL_HANDLE_DBC;
3762
3753
  end_X_args->completionType = SQL_ROLLBACK; /*Remeber you are rolling back the transaction*/
3763
3754
 
3764
- #ifdef UNICODE_SUPPORT_VERSION
3755
+ #ifdef UNICODE_SUPPORT_VERSION_H
3765
3756
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
3766
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
3757
+ RUBY_UBF_IO, NULL);
3767
3758
  rc = end_X_args->rc;
3768
3759
  #else
3769
3760
  rc = _ruby_ibm_db_SQLEndTran( end_X_args );
@@ -3780,9 +3771,9 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
3780
3771
  }
3781
3772
  }
3782
3773
 
3783
- #ifdef UNICODE_SUPPORT_VERSION
3774
+ #ifdef UNICODE_SUPPORT_VERSION_H
3784
3775
  rc = ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLDisconnect_helper, &(conn_res->hdbc),
3785
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
3776
+ RUBY_UBF_IO, NULL);
3786
3777
  #else
3787
3778
  rc = _ruby_ibm_db_SQLDisconnect_helper( &(conn_res->hdbc) );
3788
3779
  #endif
@@ -3868,7 +3859,7 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3868
3859
  VALUE r_table_name = Qnil;
3869
3860
  VALUE r_column_name = Qnil;
3870
3861
 
3871
- #ifdef UNICODE_SUPPORT_VERSION
3862
+ #ifdef UNICODE_SUPPORT_VERSION_H
3872
3863
  VALUE r_qualifier_utf16 = Qnil;
3873
3864
  VALUE r_owner_utf16 = Qnil;
3874
3865
  VALUE r_table_name_utf16 = Qnil;
@@ -3916,7 +3907,7 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3916
3907
  return_value = Qfalse;
3917
3908
  } else {
3918
3909
  if (!NIL_P(r_qualifier)) {
3919
- #ifdef UNICODE_SUPPORT_VERSION
3910
+ #ifdef UNICODE_SUPPORT_VERSION_H
3920
3911
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
3921
3912
  col_privileges_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
3922
3913
  col_privileges_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -3926,7 +3917,7 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3926
3917
  #endif
3927
3918
  }
3928
3919
  if (!NIL_P(r_owner)) {
3929
- #ifdef UNICODE_SUPPORT_VERSION
3920
+ #ifdef UNICODE_SUPPORT_VERSION_H
3930
3921
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
3931
3922
  col_privileges_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
3932
3923
  col_privileges_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -3936,7 +3927,7 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3936
3927
  #endif
3937
3928
  }
3938
3929
  if (!NIL_P(r_table_name)) {
3939
- #ifdef UNICODE_SUPPORT_VERSION
3930
+ #ifdef UNICODE_SUPPORT_VERSION_H
3940
3931
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
3941
3932
  col_privileges_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
3942
3933
  col_privileges_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -3946,7 +3937,7 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3946
3937
  #endif
3947
3938
  }
3948
3939
  if (!NIL_P(r_column_name)) {
3949
- #ifdef UNICODE_SUPPORT_VERSION
3940
+ #ifdef UNICODE_SUPPORT_VERSION_H
3950
3941
  r_column_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_column_name );
3951
3942
  col_privileges_args->column_name = (SQLWCHAR*) RSTRING_PTR( r_column_name_utf16 );
3952
3943
  col_privileges_args->column_name_len = (SQLSMALLINT) RSTRING_LEN( r_column_name_utf16 )/sizeof(SQLWCHAR);
@@ -3956,10 +3947,9 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
3956
3947
  #endif
3957
3948
  }
3958
3949
  col_privileges_args->stmt_res = stmt_res;
3959
-
3960
- #ifdef UNICODE_SUPPORT_VERSION
3950
+ #ifdef UNICODE_SUPPORT_VERSION_H
3961
3951
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColumnPrivileges_helper, col_privileges_args,
3962
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3952
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
3963
3953
  rc = col_privileges_args->rc;
3964
3954
  #else
3965
3955
  rc = _ruby_ibm_db_SQLColumnPrivileges_helper( col_privileges_args );
@@ -4048,7 +4038,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4048
4038
  VALUE r_owner = Qnil;
4049
4039
  VALUE r_table_name = Qnil;
4050
4040
  VALUE r_column_name = Qnil;
4051
- #ifdef UNICODE_SUPPORT_VERSION
4041
+ #ifdef UNICODE_SUPPORT_VERSION_H
4052
4042
  VALUE r_qualifier_utf16 = Qnil;
4053
4043
  VALUE r_owner_utf16 = Qnil;
4054
4044
  VALUE r_table_name_utf16 = Qnil;
@@ -4096,7 +4086,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4096
4086
  return_value = Qfalse;
4097
4087
  } else {
4098
4088
  if (!NIL_P(r_qualifier)) {
4099
- #ifdef UNICODE_SUPPORT_VERSION
4089
+ #ifdef UNICODE_SUPPORT_VERSION_H
4100
4090
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
4101
4091
  col_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
4102
4092
  col_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -4106,7 +4096,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4106
4096
  #endif
4107
4097
  }
4108
4098
  if (!NIL_P(r_owner)) {
4109
- #ifdef UNICODE_SUPPORT_VERSION
4099
+ #ifdef UNICODE_SUPPORT_VERSION_H
4110
4100
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
4111
4101
  col_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
4112
4102
  col_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -4116,7 +4106,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4116
4106
  #endif
4117
4107
  }
4118
4108
  if (!NIL_P(r_table_name)) {
4119
- #ifdef UNICODE_SUPPORT_VERSION
4109
+ #ifdef UNICODE_SUPPORT_VERSION_H
4120
4110
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
4121
4111
  col_metadata_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
4122
4112
  col_metadata_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -4126,7 +4116,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4126
4116
  #endif
4127
4117
  }
4128
4118
  if (!NIL_P(r_column_name)) {
4129
- #ifdef UNICODE_SUPPORT_VERSION
4119
+ #ifdef UNICODE_SUPPORT_VERSION_H
4130
4120
  r_column_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_column_name );
4131
4121
  col_metadata_args->column_name = (SQLWCHAR*) RSTRING_PTR( r_column_name_utf16 );
4132
4122
  col_metadata_args->column_name_len = (SQLSMALLINT) RSTRING_LEN( r_column_name_utf16 )/sizeof(SQLWCHAR);
@@ -4137,8 +4127,8 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
4137
4127
  }
4138
4128
  col_metadata_args->stmt_res = stmt_res;
4139
4129
 
4140
- #ifdef UNICODE_SUPPORT_VERSION
4141
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColumns_helper, col_metadata_args,
4130
+ #ifdef UNICODE_SUPPORT_VERSION_H
4131
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColumns_helper, col_metadata_args,
4142
4132
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4143
4133
  rc = col_metadata_args->rc;
4144
4134
  #else
@@ -4228,7 +4218,7 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4228
4218
  VALUE r_table_name = Qnil;
4229
4219
  VALUE r_is_fk_table = Qfalse;
4230
4220
 
4231
- #ifdef UNICODE_SUPPORT_VERSION
4221
+ #ifdef UNICODE_SUPPORT_VERSION_H
4232
4222
  VALUE r_qualifier_utf16 = Qnil;
4233
4223
  VALUE r_owner_utf16 = Qnil;
4234
4224
  VALUE r_table_name_utf16 = Qnil;
@@ -4277,7 +4267,7 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4277
4267
  return_value = Qfalse;
4278
4268
  } else {
4279
4269
  if (!NIL_P(r_qualifier)) {
4280
- #ifdef UNICODE_SUPPORT_VERSION
4270
+ #ifdef UNICODE_SUPPORT_VERSION_H
4281
4271
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
4282
4272
  col_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
4283
4273
  col_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -4287,7 +4277,7 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4287
4277
  #endif
4288
4278
  }
4289
4279
  if (!NIL_P(r_owner)) {
4290
- #ifdef UNICODE_SUPPORT_VERSION
4280
+ #ifdef UNICODE_SUPPORT_VERSION_H
4291
4281
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
4292
4282
  col_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
4293
4283
  col_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -4297,7 +4287,7 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4297
4287
  #endif
4298
4288
  }
4299
4289
  if (!NIL_P(r_table_name)) {
4300
- #ifdef UNICODE_SUPPORT_VERSION
4290
+ #ifdef UNICODE_SUPPORT_VERSION_H
4301
4291
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
4302
4292
  col_metadata_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
4303
4293
  col_metadata_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -4309,8 +4299,8 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
4309
4299
 
4310
4300
  col_metadata_args->stmt_res = stmt_res;
4311
4301
 
4312
- #ifdef UNICODE_SUPPORT_VERSION
4313
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLForeignKeys_helper, col_metadata_args,
4302
+ #ifdef UNICODE_SUPPORT_VERSION_H
4303
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLForeignKeys_helper, col_metadata_args,
4314
4304
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4315
4305
  rc = col_metadata_args->rc;
4316
4306
  #else
@@ -4388,7 +4378,7 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
4388
4378
  VALUE r_qualifier = Qnil;
4389
4379
  VALUE r_owner = Qnil;
4390
4380
  VALUE r_table_name = Qnil;
4391
- #ifdef UNICODE_SUPPORT_VERSION
4381
+ #ifdef UNICODE_SUPPORT_VERSION_H
4392
4382
  VALUE r_qualifier_utf16 = Qnil;
4393
4383
  VALUE r_owner_utf16 = Qnil;
4394
4384
  VALUE r_table_name_utf16 = Qnil;
@@ -4434,7 +4424,7 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
4434
4424
  return_value = Qfalse;
4435
4425
  } else {
4436
4426
  if (!NIL_P(r_qualifier)) {
4437
- #ifdef UNICODE_SUPPORT_VERSION
4427
+ #ifdef UNICODE_SUPPORT_VERSION_H
4438
4428
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
4439
4429
  col_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
4440
4430
  col_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -4444,7 +4434,7 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
4444
4434
  #endif
4445
4435
  }
4446
4436
  if (!NIL_P(r_owner)) {
4447
- #ifdef UNICODE_SUPPORT_VERSION
4437
+ #ifdef UNICODE_SUPPORT_VERSION_H
4448
4438
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
4449
4439
  col_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
4450
4440
  col_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -4454,7 +4444,7 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
4454
4444
  #endif
4455
4445
  }
4456
4446
  if (!NIL_P(r_table_name)) {
4457
- #ifdef UNICODE_SUPPORT_VERSION
4447
+ #ifdef UNICODE_SUPPORT_VERSION_H
4458
4448
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
4459
4449
  col_metadata_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
4460
4450
  col_metadata_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -4465,8 +4455,8 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
4465
4455
  }
4466
4456
  col_metadata_args->stmt_res = stmt_res;
4467
4457
 
4468
- #ifdef UNICODE_SUPPORT_VERSION
4469
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrimaryKeys_helper, col_metadata_args,
4458
+ #ifdef UNICODE_SUPPORT_VERSION_H
4459
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrimaryKeys_helper, col_metadata_args,
4470
4460
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4471
4461
  rc = col_metadata_args->rc;
4472
4462
  #else
@@ -4566,7 +4556,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4566
4556
  VALUE r_proc_name = Qnil;
4567
4557
  VALUE r_column_name = Qnil;
4568
4558
 
4569
- #ifdef UNICODE_SUPPORT_VERSION
4559
+ #ifdef UNICODE_SUPPORT_VERSION_H
4570
4560
  VALUE r_qualifier_utf16 = Qnil;
4571
4561
  VALUE r_owner_utf16 = Qnil;
4572
4562
  VALUE r_proc_name_utf16 = Qnil;
@@ -4615,7 +4605,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4615
4605
  return_value = Qfalse;
4616
4606
  } else {
4617
4607
  if (!NIL_P(r_qualifier)) {
4618
- #ifdef UNICODE_SUPPORT_VERSION
4608
+ #ifdef UNICODE_SUPPORT_VERSION_H
4619
4609
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
4620
4610
  col_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
4621
4611
  col_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -4625,7 +4615,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4625
4615
  #endif
4626
4616
  }
4627
4617
  if (!NIL_P(r_owner)) {
4628
- #ifdef UNICODE_SUPPORT_VERSION
4618
+ #ifdef UNICODE_SUPPORT_VERSION_H
4629
4619
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
4630
4620
  col_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
4631
4621
  col_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -4635,7 +4625,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4635
4625
  #endif
4636
4626
  }
4637
4627
  if (!NIL_P(r_proc_name)) {
4638
- #ifdef UNICODE_SUPPORT_VERSION
4628
+ #ifdef UNICODE_SUPPORT_VERSION_H
4639
4629
  r_proc_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_proc_name );
4640
4630
  col_metadata_args->proc_name = (SQLWCHAR*) RSTRING_PTR( r_proc_name_utf16 );
4641
4631
  col_metadata_args->proc_name_len = (SQLSMALLINT) RSTRING_LEN( r_proc_name_utf16 )/sizeof(SQLWCHAR);
@@ -4645,7 +4635,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4645
4635
  #endif
4646
4636
  }
4647
4637
  if (!NIL_P(r_column_name)) {
4648
- #ifdef UNICODE_SUPPORT_VERSION
4638
+ #ifdef UNICODE_SUPPORT_VERSION_H
4649
4639
  r_column_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_column_name );
4650
4640
  col_metadata_args->column_name = (SQLWCHAR*) RSTRING_PTR( r_column_name_utf16 );
4651
4641
  col_metadata_args->column_name_len = (SQLSMALLINT) RSTRING_LEN( r_column_name_utf16 )/sizeof(SQLWCHAR);
@@ -4656,9 +4646,9 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
4656
4646
  }
4657
4647
  col_metadata_args->stmt_res = stmt_res;
4658
4648
 
4659
- #ifdef UNICODE_SUPPORT_VERSION
4660
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedureColumns_helper, col_metadata_args,
4661
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
4649
+ #ifdef UNICODE_SUPPORT_VERSION_H
4650
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedureColumns_helper, col_metadata_args,
4651
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4662
4652
  rc = col_metadata_args->rc;
4663
4653
  #else
4664
4654
  rc = _ruby_ibm_db_SQLProcedureColumns_helper( col_metadata_args );
@@ -4736,7 +4726,7 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4736
4726
  VALUE r_owner = Qnil;
4737
4727
  VALUE r_proc_name = Qnil;
4738
4728
 
4739
- #ifdef UNICODE_SUPPORT_VERSION
4729
+ #ifdef UNICODE_SUPPORT_VERSION_H
4740
4730
  VALUE r_qualifier_utf16 = Qnil;
4741
4731
  VALUE r_owner_utf16 = Qnil;
4742
4732
  VALUE r_proc_name_utf16 = Qnil;
@@ -4782,7 +4772,7 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4782
4772
  return_value = Qfalse;
4783
4773
  } else {
4784
4774
  if (!NIL_P(r_qualifier)) {
4785
- #ifdef UNICODE_SUPPORT_VERSION
4775
+ #ifdef UNICODE_SUPPORT_VERSION_H
4786
4776
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
4787
4777
  proc_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
4788
4778
  proc_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -4792,7 +4782,7 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4792
4782
  #endif
4793
4783
  }
4794
4784
  if (!NIL_P(r_owner)) {
4795
- #ifdef UNICODE_SUPPORT_VERSION
4785
+ #ifdef UNICODE_SUPPORT_VERSION_H
4796
4786
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
4797
4787
  proc_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
4798
4788
  proc_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -4802,7 +4792,7 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4802
4792
  #endif
4803
4793
  }
4804
4794
  if (!NIL_P(r_proc_name)) {
4805
- #ifdef UNICODE_SUPPORT_VERSION
4795
+ #ifdef UNICODE_SUPPORT_VERSION_H
4806
4796
  r_proc_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_proc_name );
4807
4797
  proc_metadata_args->proc_name = (SQLWCHAR*) RSTRING_PTR( r_proc_name_utf16 );
4808
4798
  proc_metadata_args->proc_name_len = (SQLSMALLINT) RSTRING_LEN( r_proc_name_utf16 )/sizeof(SQLWCHAR);
@@ -4813,8 +4803,8 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
4813
4803
  }
4814
4804
  proc_metadata_args->stmt_res = stmt_res;
4815
4805
 
4816
- #ifdef UNICODE_SUPPORT_VERSION
4817
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedures_helper, proc_metadata_args,
4806
+ #ifdef UNICODE_SUPPORT_VERSION_H
4807
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLProcedures_helper, proc_metadata_args,
4818
4808
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
4819
4809
  rc = proc_metadata_args->rc;
4820
4810
  #else
@@ -4908,7 +4898,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4908
4898
  VALUE r_qualifier = Qnil;
4909
4899
  VALUE r_owner = Qnil;
4910
4900
  VALUE r_table_name = Qnil;
4911
- #ifdef UNICODE_SUPPORT_VERSION
4901
+ #ifdef UNICODE_SUPPORT_VERSION_H
4912
4902
  VALUE r_qualifier_utf16 = Qnil;
4913
4903
  VALUE r_owner_utf16 = Qnil;
4914
4904
  VALUE r_table_name_utf16 = Qnil;
@@ -4956,7 +4946,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4956
4946
  return_value = Qfalse;
4957
4947
  } else {
4958
4948
  if (!NIL_P(r_qualifier)) {
4959
- #ifdef UNICODE_SUPPORT_VERSION
4949
+ #ifdef UNICODE_SUPPORT_VERSION_H
4960
4950
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
4961
4951
  col_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
4962
4952
  col_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -4966,7 +4956,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4966
4956
  #endif
4967
4957
  }
4968
4958
  if (!NIL_P(r_owner)) {
4969
- #ifdef UNICODE_SUPPORT_VERSION
4959
+ #ifdef UNICODE_SUPPORT_VERSION_H
4970
4960
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
4971
4961
  col_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
4972
4962
  col_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -4976,7 +4966,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4976
4966
  #endif
4977
4967
  }
4978
4968
  if (!NIL_P(r_table_name)) {
4979
- #ifdef UNICODE_SUPPORT_VERSION
4969
+ #ifdef UNICODE_SUPPORT_VERSION_H
4980
4970
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
4981
4971
  col_metadata_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
4982
4972
  col_metadata_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -4990,9 +4980,9 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
4990
4980
  }
4991
4981
  col_metadata_args->stmt_res = stmt_res;
4992
4982
 
4993
- #ifdef UNICODE_SUPPORT_VERSION
4994
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLSpecialColumns_helper, col_metadata_args,
4995
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
4983
+ #ifdef UNICODE_SUPPORT_VERSION_H
4984
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLSpecialColumns_helper, col_metadata_args,
4985
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
4996
4986
  rc = col_metadata_args->rc;
4997
4987
  #else
4998
4988
  rc = _ruby_ibm_db_SQLSpecialColumns_helper( col_metadata_args );
@@ -5106,7 +5096,7 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5106
5096
  VALUE r_owner = Qnil;
5107
5097
  VALUE r_table_name = Qnil;
5108
5098
  VALUE r_unique = Qnil;
5109
- #ifdef UNICODE_SUPPORT_VERSION
5099
+ #ifdef UNICODE_SUPPORT_VERSION_H
5110
5100
  VALUE r_qualifier_utf16 = Qnil;
5111
5101
  VALUE r_owner_utf16 = Qnil;
5112
5102
  VALUE r_table_name_utf16 = Qnil;
@@ -5152,7 +5142,7 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5152
5142
  return_value = Qfalse;
5153
5143
  } else {
5154
5144
  if (!NIL_P(r_qualifier)) {
5155
- #ifdef UNICODE_SUPPORT_VERSION
5145
+ #ifdef UNICODE_SUPPORT_VERSION_H
5156
5146
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
5157
5147
  col_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
5158
5148
  col_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -5162,7 +5152,7 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5162
5152
  #endif
5163
5153
  }
5164
5154
  if (!NIL_P(r_owner)) {
5165
- #ifdef UNICODE_SUPPORT_VERSION
5155
+ #ifdef UNICODE_SUPPORT_VERSION_H
5166
5156
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
5167
5157
  col_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
5168
5158
  col_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -5172,7 +5162,7 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5172
5162
  #endif
5173
5163
  }
5174
5164
  if (!NIL_P(r_table_name)) {
5175
- #ifdef UNICODE_SUPPORT_VERSION
5165
+ #ifdef UNICODE_SUPPORT_VERSION_H
5176
5166
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
5177
5167
  col_metadata_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
5178
5168
  col_metadata_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -5186,9 +5176,9 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
5186
5176
  }
5187
5177
  col_metadata_args->stmt_res = stmt_res;
5188
5178
 
5189
- #ifdef UNICODE_SUPPORT_VERSION
5179
+ #ifdef UNICODE_SUPPORT_VERSION_H
5190
5180
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLStatistics_helper, col_metadata_args,
5191
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5181
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5192
5182
  rc = col_metadata_args->rc;
5193
5183
  #else
5194
5184
  rc = _ruby_ibm_db_SQLStatistics_helper( col_metadata_args );
@@ -5268,7 +5258,7 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
5268
5258
  VALUE r_qualifier = Qnil;
5269
5259
  VALUE r_owner = Qnil;
5270
5260
  VALUE r_table_name = Qnil;
5271
- #ifdef UNICODE_SUPPORT_VERSION
5261
+ #ifdef UNICODE_SUPPORT_VERSION_H
5272
5262
  VALUE r_qualifier_utf16 = Qnil;
5273
5263
  VALUE r_owner_utf16 = Qnil;
5274
5264
  VALUE r_table_name_utf16 = Qnil;
@@ -5313,7 +5303,7 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
5313
5303
  return_value = Qfalse;
5314
5304
  } else {
5315
5305
  if (!NIL_P(r_qualifier)) {
5316
- #ifdef UNICODE_SUPPORT_VERSION
5306
+ #ifdef UNICODE_SUPPORT_VERSION_H
5317
5307
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
5318
5308
  table_privileges_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
5319
5309
  table_privileges_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -5323,7 +5313,7 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
5323
5313
  #endif
5324
5314
  }
5325
5315
  if (!NIL_P(r_owner)) {
5326
- #ifdef UNICODE_SUPPORT_VERSION
5316
+ #ifdef UNICODE_SUPPORT_VERSION_H
5327
5317
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
5328
5318
  table_privileges_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
5329
5319
  table_privileges_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -5333,7 +5323,7 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
5333
5323
  #endif
5334
5324
  }
5335
5325
  if (!NIL_P(r_table_name)) {
5336
- #ifdef UNICODE_SUPPORT_VERSION
5326
+ #ifdef UNICODE_SUPPORT_VERSION_H
5337
5327
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
5338
5328
  table_privileges_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
5339
5329
  table_privileges_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -5345,9 +5335,9 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
5345
5335
 
5346
5336
  table_privileges_args->stmt_res = stmt_res;
5347
5337
 
5348
- #ifdef UNICODE_SUPPORT_VERSION
5349
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTablePrivileges_helper, table_privileges_args,
5350
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5338
+ #ifdef UNICODE_SUPPORT_VERSION_H
5339
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTablePrivileges_helper, table_privileges_args,
5340
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5351
5341
  rc = table_privileges_args->rc;
5352
5342
  #else
5353
5343
  rc = _ruby_ibm_db_SQLTablePrivileges_helper( table_privileges_args );
@@ -5428,7 +5418,7 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5428
5418
  VALUE r_owner = Qnil;
5429
5419
  VALUE r_table_name = Qnil;
5430
5420
  VALUE r_table_type = Qnil;
5431
- #ifdef UNICODE_SUPPORT_VERSION
5421
+ #ifdef UNICODE_SUPPORT_VERSION_H
5432
5422
  VALUE r_qualifier_utf16 = Qnil;
5433
5423
  VALUE r_owner_utf16 = Qnil;
5434
5424
  VALUE r_table_name_utf16 = Qnil;
@@ -5477,7 +5467,7 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5477
5467
  return_value = Qfalse;
5478
5468
  } else {
5479
5469
  if (!NIL_P(r_qualifier)) {
5480
- #ifdef UNICODE_SUPPORT_VERSION
5470
+ #ifdef UNICODE_SUPPORT_VERSION_H
5481
5471
  r_qualifier_utf16 = _ruby_ibm_db_export_str_to_utf16( r_qualifier );
5482
5472
  table_metadata_args->qualifier = (SQLWCHAR*) RSTRING_PTR( r_qualifier_utf16 );
5483
5473
  table_metadata_args->qualifier_len = (SQLSMALLINT) RSTRING_LEN( r_qualifier_utf16 )/sizeof(SQLWCHAR);
@@ -5487,7 +5477,7 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5487
5477
  #endif
5488
5478
  }
5489
5479
  if (!NIL_P(r_owner)) {
5490
- #ifdef UNICODE_SUPPORT_VERSION
5480
+ #ifdef UNICODE_SUPPORT_VERSION_H
5491
5481
  r_owner_utf16 = _ruby_ibm_db_export_str_to_utf16( r_owner );
5492
5482
  table_metadata_args->owner = (SQLWCHAR*) RSTRING_PTR( r_owner_utf16 );
5493
5483
  table_metadata_args->owner_len = (SQLSMALLINT) RSTRING_LEN( r_owner_utf16 )/sizeof(SQLWCHAR);
@@ -5497,7 +5487,7 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5497
5487
  #endif
5498
5488
  }
5499
5489
  if (!NIL_P(r_table_name)) {
5500
- #ifdef UNICODE_SUPPORT_VERSION
5490
+ #ifdef UNICODE_SUPPORT_VERSION_H
5501
5491
  r_table_name_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_name );
5502
5492
  table_metadata_args->table_name = (SQLWCHAR*) RSTRING_PTR( r_table_name_utf16 );
5503
5493
  table_metadata_args->table_name_len = (SQLSMALLINT) RSTRING_LEN( r_table_name_utf16 )/sizeof(SQLWCHAR);
@@ -5507,7 +5497,7 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5507
5497
  #endif
5508
5498
  }
5509
5499
  if (!NIL_P(r_table_type)) {
5510
- #ifdef UNICODE_SUPPORT_VERSION
5500
+ #ifdef UNICODE_SUPPORT_VERSION_H
5511
5501
  r_table_type_utf16 = _ruby_ibm_db_export_str_to_utf16( r_table_type );
5512
5502
  table_metadata_args->table_type = (SQLWCHAR*) RSTRING_PTR( r_table_type_utf16 );
5513
5503
  table_metadata_args->table_type_len = (SQLSMALLINT) RSTRING_LEN( r_table_type_utf16 )/sizeof(SQLWCHAR);
@@ -5519,8 +5509,8 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
5519
5509
 
5520
5510
  table_metadata_args->stmt_res = stmt_res;
5521
5511
 
5522
- #ifdef UNICODE_SUPPORT_VERSION
5523
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTables_helper, table_metadata_args,
5512
+ #ifdef UNICODE_SUPPORT_VERSION_H
5513
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLTables_helper, table_metadata_args,
5524
5514
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5525
5515
  rc = table_metadata_args->rc;
5526
5516
  #else
@@ -5601,9 +5591,9 @@ VALUE ibm_db_commit(int argc, VALUE *argv, VALUE self)
5601
5591
  end_X_args->handleType = SQL_HANDLE_DBC;
5602
5592
  end_X_args->completionType = SQL_COMMIT; /*Remeber you are Commiting the transaction*/
5603
5593
 
5604
- #ifdef UNICODE_SUPPORT_VERSION
5594
+ #ifdef UNICODE_SUPPORT_VERSION_H
5605
5595
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
5606
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
5596
+ RUBY_UBF_IO, NULL);
5607
5597
  rc = end_X_args->rc;
5608
5598
  #else
5609
5599
  rc = _ruby_ibm_db_SQLEndTran( end_X_args );
@@ -5637,7 +5627,7 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
5637
5627
 
5638
5628
  VALUE error = Qnil;
5639
5629
 
5640
- #ifdef UNICODE_SUPPORT_VERSION
5630
+ #ifdef UNICODE_SUPPORT_VERSION_H
5641
5631
  VALUE stmt_utf16 = Qnil;
5642
5632
  #endif
5643
5633
 
@@ -5647,7 +5637,7 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
5647
5637
  if ( !NIL_P(stmt) ) {
5648
5638
  prepare_args = ALLOC( exec_cum_prepare_args );
5649
5639
  memset(prepare_args,'\0',sizeof(struct _ibm_db_exec_direct_args_struct));
5650
- #ifdef UNICODE_SUPPORT_VERSION
5640
+ #ifdef UNICODE_SUPPORT_VERSION_H
5651
5641
  stmt_utf16 = _ruby_ibm_db_export_str_to_utf16(stmt);
5652
5642
  prepare_args->stmt_string = (SQLWCHAR*) RSTRING_PTR(stmt_utf16);
5653
5643
  prepare_args->stmt_string_len = RSTRING_LEN(stmt_utf16)/sizeof(SQLWCHAR);
@@ -5681,9 +5671,9 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
5681
5671
  prepare_args->stmt_res = stmt_res;
5682
5672
 
5683
5673
  /* Prepare the stmt. The cursor type requested has already been set in _ruby_ibm_db_assign_options */
5684
- #ifdef UNICODE_SUPPORT_VERSION
5685
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrepare_helper, prepare_args,
5686
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5674
+ #ifdef UNICODE_SUPPORT_VERSION_H
5675
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLPrepare_helper, prepare_args,
5676
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5687
5677
  rc = prepare_args->rc;
5688
5678
  #else
5689
5679
  rc = _ruby_ibm_db_SQLPrepare_helper( prepare_args );
@@ -5747,7 +5737,7 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
5747
5737
  VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
5748
5738
  {
5749
5739
  VALUE stmt = Qnil;
5750
- #ifdef UNICODE_SUPPORT_VERSION
5740
+ #ifdef UNICODE_SUPPORT_VERSION_H
5751
5741
  VALUE stmt_utf16 = Qnil;
5752
5742
  #endif
5753
5743
  VALUE connection = Qnil;
@@ -5779,7 +5769,7 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
5779
5769
  exec_direct_args = ALLOC( exec_cum_prepare_args );
5780
5770
  memset(exec_direct_args,'\0',sizeof(struct _ibm_db_exec_direct_args_struct));
5781
5771
 
5782
- #ifdef UNICODE_SUPPORT_VERSION
5772
+ #ifdef UNICODE_SUPPORT_VERSION_H
5783
5773
  stmt_utf16 = _ruby_ibm_db_export_str_to_utf16(stmt);
5784
5774
  exec_direct_args->stmt_string = (SQLWCHAR*)RSTRING_PTR(stmt_utf16);
5785
5775
  exec_direct_args->stmt_string_len = RSTRING_LEN(stmt_utf16)/sizeof(SQLWCHAR); /*RSTRING_LEN returns number of bytes*/
@@ -5823,9 +5813,9 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
5823
5813
  exec_direct_args->stmt_res = stmt_res;
5824
5814
 
5825
5815
 
5826
- #ifdef UNICODE_SUPPORT_VERSION
5827
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLExecDirect_helper, exec_direct_args,
5828
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5816
+ #ifdef UNICODE_SUPPORT_VERSION_H
5817
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLExecDirect_helper, exec_direct_args,
5818
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5829
5819
  rc = exec_direct_args->rc;
5830
5820
  #else
5831
5821
  rc = _ruby_ibm_db_SQLExecDirect_helper( exec_direct_args );
@@ -5882,7 +5872,7 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
5882
5872
  stmt_handle *stmt_res = NULL;
5883
5873
  free_stmt_args *freeStmt_args = NULL;
5884
5874
 
5885
- #ifdef UNICODE_SUPPORT_VERSION
5875
+ #ifdef UNICODE_SUPPORT_VERSION_H
5886
5876
  char *err_str = NULL;
5887
5877
  #endif
5888
5878
 
@@ -5897,8 +5887,8 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
5897
5887
  freeStmt_args->stmt_res = stmt_res;
5898
5888
  freeStmt_args->option = SQL_CLOSE;
5899
5889
 
5900
- #ifdef UNICODE_SUPPORT_VERSION
5901
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLFreeStmt_helper, freeStmt_args,
5890
+ #ifdef UNICODE_SUPPORT_VERSION_H
5891
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLFreeStmt_helper, freeStmt_args,
5902
5892
  (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
5903
5893
  rc = freeStmt_args->rc;
5904
5894
  #else
@@ -5910,7 +5900,7 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
5910
5900
 
5911
5901
  if ( rc == SQL_ERROR ) {
5912
5902
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 1 );
5913
- #ifdef UNICODE_SUPPORT_VERSION
5903
+ #ifdef UNICODE_SUPPORT_VERSION_H
5914
5904
  err_str = RSTRING_PTR(
5915
5905
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
5916
5906
  stmt_res->ruby_stmt_err_msg_len )
@@ -5988,7 +5978,7 @@ VALUE ibm_db_prepare(int argc, VALUE *argv, VALUE self)
5988
5978
  conn_handle *conn_res;
5989
5979
  stmt_handle *stmt_res;
5990
5980
 
5991
- #ifdef UNICODE_SUPPORT_VERSION
5981
+ #ifdef UNICODE_SUPPORT_VERSION_H
5992
5982
  char *err_str = NULL;
5993
5983
  #endif
5994
5984
 
@@ -6022,7 +6012,7 @@ VALUE ibm_db_prepare(int argc, VALUE *argv, VALUE self)
6022
6012
  _ruby_ibm_db_free_stmt_struct(stmt_res);
6023
6013
  stmt_res = NULL;
6024
6014
 
6025
- #ifdef UNICODE_SUPPORT_VERSION
6015
+ #ifdef UNICODE_SUPPORT_VERSION_H
6026
6016
  err_str = RSTRING_PTR( _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( conn_res->ruby_error_msg,
6027
6017
  DB2_MAX_ERR_MSG_LEN * sizeof(SQLWCHAR) )
6028
6018
  );
@@ -6088,13 +6078,13 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6088
6078
  int rc;
6089
6079
  int origlen = 0;
6090
6080
  int is_known_type = 1;
6091
- #ifdef UNICODE_SUPPORT_VERSION
6081
+ #ifdef UNICODE_SUPPORT_VERSION_H
6092
6082
  int is_binary = 0; /*Indicates if the column is either SQL_BLOB, SQL_BINARY, SQL_VARBINARY or SQL_LONGVARBINARY*/
6093
6083
  #endif
6094
6084
 
6095
6085
  SQLPOINTER tmp_str;
6096
6086
 
6097
- #ifdef UNICODE_SUPPORT_VERSION
6087
+ #ifdef UNICODE_SUPPORT_VERSION_H
6098
6088
  VALUE bindData_utf16;
6099
6089
  VALUE tmpBuff;
6100
6090
  #endif
@@ -6116,7 +6106,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6116
6106
 
6117
6107
  switch(TYPE(*bind_data)) {
6118
6108
  case T_BIGNUM:
6119
- #ifdef UNICODE_SUPPORT_VERSION
6109
+ #ifdef UNICODE_SUPPORT_VERSION_H
6120
6110
  tmpBuff = rb_big2str(*bind_data,10);
6121
6111
  tmp_str = (SQLCHAR *) RSTRING_PTR(tmpBuff);
6122
6112
  curr->ivalue = RSTRING_LEN(tmpBuff);
@@ -6196,7 +6186,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6196
6186
  break;
6197
6187
 
6198
6188
  case T_STRING:
6199
- #ifdef UNICODE_SUPPORT_VERSION
6189
+ #ifdef UNICODE_SUPPORT_VERSION_H
6200
6190
  if( curr->data_type == SQL_BLOB || curr->data_type == SQL_LONGVARBINARY || curr->data_type == SQL_VARBINARY ||
6201
6191
  curr->data_type == SQL_BINARY || curr->data_type == SQL_XML ){
6202
6192
  is_binary = 1;
@@ -6223,7 +6213,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6223
6213
  * given then use BUFSIZ to return the string.
6224
6214
  */
6225
6215
  if ( curr->size <= 0 ) {
6226
- #ifdef UNICODE_SUPPORT_VERSION
6216
+ #ifdef UNICODE_SUPPORT_VERSION_H
6227
6217
  if( is_binary ) {
6228
6218
  if (curr->ivalue < curr->param_size ) {
6229
6219
  curr->ivalue = curr->param_size;
@@ -6247,7 +6237,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6247
6237
  #endif
6248
6238
  } else {
6249
6239
  if( curr->param_type == SQL_PARAM_INPUT_OUTPUT ) {
6250
- #ifdef UNICODE_SUPPORT_VERSION
6240
+ #ifdef UNICODE_SUPPORT_VERSION_H
6251
6241
  if( is_binary ) {
6252
6242
  if( curr->size > curr->ivalue ) {
6253
6243
  curr->ivalue = curr->size + 1;
@@ -6269,7 +6259,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6269
6259
  }
6270
6260
  #endif
6271
6261
  } else {
6272
- #ifdef UNICODE_SUPPORT_VERSION
6262
+ #ifdef UNICODE_SUPPORT_VERSION_H
6273
6263
  if( is_binary ) {
6274
6264
  curr->ivalue = curr->size + 1;
6275
6265
  } else {
@@ -6288,7 +6278,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6288
6278
  }
6289
6279
  }
6290
6280
 
6291
- #ifdef UNICODE_SUPPORT_VERSION
6281
+ #ifdef UNICODE_SUPPORT_VERSION_H
6292
6282
  if( is_binary ){
6293
6283
  curr->svalue = (SQLCHAR *) ALLOC_N(SQLCHAR, curr->ivalue);
6294
6284
  } else {
@@ -6320,7 +6310,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6320
6310
  paramValuePtr = (SQLPOINTER)&(curr);
6321
6311
  #endif
6322
6312
  }
6323
- #ifdef UNICODE_SUPPORT_VERSION
6313
+ #ifdef UNICODE_SUPPORT_VERSION_H
6324
6314
  valueType = SQL_C_WCHAR;
6325
6315
  #else
6326
6316
  valueType = SQL_C_CHAR;
@@ -6369,7 +6359,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
6369
6359
  }
6370
6360
  }
6371
6361
  bindParameter_args->buff_length = curr->ivalue;
6372
- #ifdef UNICODE_SUPPORT_VERSION
6362
+ #ifdef UNICODE_SUPPORT_VERSION_H
6373
6363
  valueType = SQL_C_WCHAR;
6374
6364
  #else
6375
6365
  valueType = SQL_C_CHAR;
@@ -6431,7 +6421,7 @@ static int _ruby_ibm_db_bind_data( stmt_handle *stmt_res, param_node *curr, VALU
6431
6421
  }
6432
6422
  curr->bind_indicator = 0;
6433
6423
 
6434
- #ifdef UNICODE_SUPPORT_VERSION
6424
+ #ifdef UNICODE_SUPPORT_VERSION_H
6435
6425
  curr->svalue = (SQLCHAR *) RSTRING_PTR(*bind_data);
6436
6426
  curr->ivalue = RSTRING_LEN(*bind_data);
6437
6427
  #else
@@ -6472,7 +6462,7 @@ static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, VALUE *error ) {
6472
6462
 
6473
6463
  if ( rc == SQL_ERROR ) {
6474
6464
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6475
- #ifdef UNICODE_SUPPORT_VERSION
6465
+ #ifdef UNICODE_SUPPORT_VERSION_H
6476
6466
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Binding Error 1: "),
6477
6467
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6478
6468
  stmt_res->ruby_stmt_err_msg_len )
@@ -6481,7 +6471,7 @@ static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, VALUE *error ) {
6481
6471
  *error = rb_str_cat2(rb_str_new2("Binding Error 1: "), stmt_res->ruby_stmt_err_msg );
6482
6472
  #endif
6483
6473
  } else {
6484
- #ifdef UNICODE_SUPPORT_VERSION
6474
+ #ifdef UNICODE_SUPPORT_VERSION_H
6485
6475
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Binding Error 1: <error message could not be retrieved>");
6486
6476
  #else
6487
6477
  *error = rb_str_new2("Binding Error 1: <error message could not be retrieved>");
@@ -6543,7 +6533,7 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
6543
6533
  if ( rc == SQL_ERROR ) {
6544
6534
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
6545
6535
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6546
- #ifdef UNICODE_SUPPORT_VERSION
6536
+ #ifdef UNICODE_SUPPORT_VERSION_H
6547
6537
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr( "Describe Param Failed: " ),
6548
6538
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6549
6539
  stmt_res->ruby_stmt_err_msg_len )
@@ -6552,7 +6542,7 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
6552
6542
  *error = rb_str_cat2(rb_str_new2("Describe Param Failed: "), stmt_res->ruby_stmt_err_msg );
6553
6543
  #endif
6554
6544
  } else {
6555
- #ifdef UNICODE_SUPPORT_VERSION
6545
+ #ifdef UNICODE_SUPPORT_VERSION_H
6556
6546
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Describe Param Failed: <error message could not be retrieved>");
6557
6547
  #else
6558
6548
  *error = rb_str_new2("Describe Param Failed: <error message could not be retrieved>");
@@ -6579,7 +6569,7 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
6579
6569
 
6580
6570
  if ( rc == SQL_ERROR ) {
6581
6571
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6582
- #ifdef UNICODE_SUPPORT_VERSION
6572
+ #ifdef UNICODE_SUPPORT_VERSION_H
6583
6573
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Binding Error 2: "),
6584
6574
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6585
6575
  stmt_res->ruby_stmt_err_msg_len )
@@ -6588,7 +6578,7 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
6588
6578
  *error = rb_str_cat2(rb_str_new2("Binding Error 2: "), stmt_res->ruby_stmt_err_msg );
6589
6579
  #endif
6590
6580
  } else {
6591
- #ifdef UNICODE_SUPPORT_VERSION
6581
+ #ifdef UNICODE_SUPPORT_VERSION_H
6592
6582
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Binding Error 2: <error message could not be retrieved>");
6593
6583
  #else
6594
6584
  *error = rb_str_new2("Binding Error 2: <error message could not be retrieved>");
@@ -6609,7 +6599,7 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
6609
6599
 
6610
6600
  if ( rc == SQL_ERROR ) {
6611
6601
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6612
- #ifdef UNICODE_SUPPORT_VERSION
6602
+ #ifdef UNICODE_SUPPORT_VERSION_H
6613
6603
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Binding Error 2: "),
6614
6604
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6615
6605
  stmt_res->ruby_stmt_err_msg_len )
@@ -6618,7 +6608,7 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
6618
6608
  *error = rb_str_cat2(rb_str_new2("Binding Error 2: "), stmt_res->ruby_stmt_err_msg );
6619
6609
  #endif
6620
6610
  } else {
6621
- #ifdef UNICODE_SUPPORT_VERSION
6611
+ #ifdef UNICODE_SUPPORT_VERSION_H
6622
6612
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Binding Error 2: <error message could not be retrieved>");
6623
6613
  #else
6624
6614
  *error = rb_str_new2("Binding Error 2: <error message could not be retrieved>");
@@ -6649,7 +6639,7 @@ void var_assign(char *name, VALUE value) {
6649
6639
  inspect = rb_intern("inspect");
6650
6640
  value = rb_funcall(value, inspect, 0);
6651
6641
 
6652
- #ifdef UNICODE_SUPPORT_VERSION
6642
+ #ifdef UNICODE_SUPPORT_VERSION_H
6653
6643
  expr = RSTRING_PTR(value);
6654
6644
  expr_len = RSTRING_LEN(value);
6655
6645
  #else
@@ -6687,7 +6677,7 @@ static VALUE _ruby_ibm_db_desc_and_bind_param_list(stmt_bind_array *bind_array,
6687
6677
  numOpts = bind_array->num;
6688
6678
  } else if (numOpts < bind_array->num) {
6689
6679
  /* If there are less params passed in, than are present -- Error */
6690
- #ifdef UNICODE_SUPPORT_VERSION
6680
+ #ifdef UNICODE_SUPPORT_VERSION_H
6691
6681
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Number of params passed in are less than bound parameters");
6692
6682
  #else
6693
6683
  *error = rb_str_new2("Number of params passed in are less than bound parameters");
@@ -6757,7 +6747,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6757
6747
  ruby_xfree( num_params_args );
6758
6748
  num_params_args = NULL;
6759
6749
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6760
- #ifdef UNICODE_SUPPORT_VERSION
6750
+ #ifdef UNICODE_SUPPORT_VERSION_H
6761
6751
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Execute Failed due to: "),
6762
6752
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6763
6753
  stmt_res->ruby_stmt_err_msg_len )
@@ -6766,7 +6756,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6766
6756
  *error = rb_str_cat2(rb_str_new2("Execute Failed due to: "), stmt_res->ruby_stmt_err_msg );
6767
6757
  #endif
6768
6758
  } else {
6769
- #ifdef UNICODE_SUPPORT_VERSION
6759
+ #ifdef UNICODE_SUPPORT_VERSION_H
6770
6760
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Execute Failed due to: <error message could not be retrieved>");
6771
6761
  #else
6772
6762
  *error = rb_str_new2("Execute Failed due to: <error message could not be retrieved>");
@@ -6790,7 +6780,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6790
6780
  /* Make sure IBM_DB.bind_param has been called */
6791
6781
  /* If the param list is NULL -- ERROR */
6792
6782
  if (TYPE( *(bind_array->parameters_array) ) != T_ARRAY) {
6793
- #ifdef UNICODE_SUPPORT_VERSION
6783
+ #ifdef UNICODE_SUPPORT_VERSION_H
6794
6784
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Param is not an array");
6795
6785
  #else
6796
6786
  *error = rb_str_new2("Param is not an array");
@@ -6815,7 +6805,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6815
6805
  /* No additional params passed in. Use values already bound. */
6816
6806
  if ( num > stmt_res->num_params ) {
6817
6807
  /* More parameters than we expected */
6818
- #ifdef UNICODE_SUPPORT_VERSION
6808
+ #ifdef UNICODE_SUPPORT_VERSION_H
6819
6809
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Number of params passed are more than bound parameters");
6820
6810
  #else
6821
6811
  *error = rb_str_new2("Number of params passed are more than bound parameters");
@@ -6824,7 +6814,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6824
6814
  return Qnil;
6825
6815
  } else if ( num < stmt_res->num_params ) {
6826
6816
  /* Fewer parameters than we expected */
6827
- #ifdef UNICODE_SUPPORT_VERSION
6817
+ #ifdef UNICODE_SUPPORT_VERSION_H
6828
6818
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Number of params passed are less than bound parameters");
6829
6819
  #else
6830
6820
  *error = rb_str_new2("Number of params passed are less than bound parameters");
@@ -6835,7 +6825,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6835
6825
 
6836
6826
  /* Param cache node list is empty -- No params bound */
6837
6827
  if ( stmt_res->head_cache_list == NULL ) {
6838
- #ifdef UNICODE_SUPPORT_VERSION
6828
+ #ifdef UNICODE_SUPPORT_VERSION_H
6839
6829
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Parameters not bound");
6840
6830
  #else
6841
6831
  *error = rb_str_new2("Parameters not bound");
@@ -6862,7 +6852,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6862
6852
  if ( rc == SQL_ERROR ) {
6863
6853
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
6864
6854
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6865
- #ifdef UNICODE_SUPPORT_VERSION
6855
+ #ifdef UNICODE_SUPPORT_VERSION_H
6866
6856
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Statement Execute Failed: "),
6867
6857
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6868
6858
  stmt_res->ruby_stmt_err_msg_len )
@@ -6871,7 +6861,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6871
6861
  *error = rb_str_cat2(rb_str_new2("Statement Execute Failed: "), stmt_res->ruby_stmt_err_msg );
6872
6862
  #endif
6873
6863
  } else {
6874
- #ifdef UNICODE_SUPPORT_VERSION
6864
+ #ifdef UNICODE_SUPPORT_VERSION_H
6875
6865
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Statement Execute Failed: <error message could not be retrieved>");
6876
6866
  #else
6877
6867
  *error = rb_str_new2("Statement Execute Failed: <error message could not be retrieved>");
@@ -6897,7 +6887,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6897
6887
  if ( rc == SQL_ERROR ) {
6898
6888
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
6899
6889
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6900
- #ifdef UNICODE_SUPPORT_VERSION
6890
+ #ifdef UNICODE_SUPPORT_VERSION_H
6901
6891
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr( "Sending data failed: "),
6902
6892
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6903
6893
  stmt_res->ruby_stmt_err_msg_len )
@@ -6906,7 +6896,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6906
6896
  *error = rb_str_cat2(rb_str_new2("Sending data failed: "), stmt_res->ruby_stmt_err_msg );
6907
6897
  #endif
6908
6898
  } else {
6909
- #ifdef UNICODE_SUPPORT_VERSION
6899
+ #ifdef UNICODE_SUPPORT_VERSION_H
6910
6900
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Sending data failed: <error message could not be retrieved>");
6911
6901
  #else
6912
6902
  *error = rb_str_new2("Sending data failed: <error message could not be retrieved>");
@@ -6931,7 +6921,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6931
6921
  if ( rc == SQL_ERROR ) {
6932
6922
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
6933
6923
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
6934
- #ifdef UNICODE_SUPPORT_VERSION
6924
+ #ifdef UNICODE_SUPPORT_VERSION_H
6935
6925
  *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr( "Sending data failed: "),
6936
6926
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
6937
6927
  stmt_res->ruby_stmt_err_msg_len )
@@ -6940,7 +6930,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
6940
6930
  *error = rb_str_cat2(rb_str_new2("Sending data failed: "), stmt_res->ruby_stmt_err_msg );
6941
6931
  #endif
6942
6932
  } else {
6943
- #ifdef UNICODE_SUPPORT_VERSION
6933
+ #ifdef UNICODE_SUPPORT_VERSION_H
6944
6934
  *error = _ruby_ibm_db_export_char_to_utf8_rstr("Sending data failed: <error message could not be retrieved>");
6945
6935
  #else
6946
6936
  *error = rb_str_new2("Sending data failed: <error message could not be retrieved>");
@@ -7015,9 +7005,9 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
7015
7005
  bind_array->num = 0;
7016
7006
  bind_array->error = &error;
7017
7007
 
7018
- #ifdef UNICODE_SUPPORT_VERSION
7019
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_execute_helper, bind_array,
7020
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7008
+ #ifdef UNICODE_SUPPORT_VERSION_H
7009
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_execute_helper, bind_array,
7010
+ RUBY_UBF_IO, NULL );
7021
7011
  ret_value = bind_array->return_value;
7022
7012
  #else
7023
7013
  ret_value = _ruby_ibm_db_execute_helper( bind_array );
@@ -7081,7 +7071,7 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
7081
7071
  var_assign(tmp_curr->varname, rb_float_new(tmp_curr->fvalue));
7082
7072
  break;
7083
7073
  case SQL_XML:
7084
- #ifdef UNICODE_SUPPORT_VERSION
7074
+ #ifdef UNICODE_SUPPORT_VERSION_H
7085
7075
  var_assign(tmp_curr->varname,rb_str_new2((char *) "")); /*Ensure it is a string object*/
7086
7076
  if( tmp_curr-> size > 0 && tmp_curr->bind_indicator > tmp_curr->size ){
7087
7077
  rb_funcall(rb_eval_string(tmp_curr->varname), rb_intern("replace"), 1, _ruby_ibm_db_export_sqlchar_to_utf8_rstr( (SQLCHAR *) tmp_curr->svalue, tmp_curr->size ));
@@ -7103,7 +7093,7 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
7103
7093
  }
7104
7094
  break;
7105
7095
  default:
7106
- #ifdef UNICODE_SUPPORT_VERSION
7096
+ #ifdef UNICODE_SUPPORT_VERSION_H
7107
7097
  var_assign(tmp_curr->varname,rb_str_new2((char *) "")); /*Ensure it is a string object*/
7108
7098
  if( tmp_curr-> size > 0 && tmp_curr->bind_indicator > (tmp_curr->size * sizeof(SQLWCHAR))+ 2 ){
7109
7099
  rb_funcall(rb_eval_string(tmp_curr->varname), rb_intern("replace"), 1, _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( (SQLWCHAR *) tmp_curr->svalue, (tmp_curr->size * sizeof(SQLWCHAR)) + 2 ));
@@ -7186,7 +7176,7 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
7186
7176
  return Qnil;
7187
7177
  }
7188
7178
 
7189
- #ifdef UNICODE_SUPPORT_VERSION
7179
+ #ifdef UNICODE_SUPPORT_VERSION_H
7190
7180
  return_str = ALLOC_N( SQLWCHAR, DB2_MAX_ERR_MSG_LEN + 1 );
7191
7181
  memset(return_str, '\0', (DB2_MAX_ERR_MSG_LEN + 1 ) * sizeof(SQLWCHAR) );
7192
7182
  #else
@@ -7201,7 +7191,7 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
7201
7191
 
7202
7192
  conn_res->errormsg_recno_tracker++;
7203
7193
 
7204
- #ifdef UNICODE_SUPPORT_VERSION
7194
+ #ifdef UNICODE_SUPPORT_VERSION_H
7205
7195
  ret_val = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( (SQLWCHAR *)return_str, return_str_len );
7206
7196
  #else
7207
7197
  ret_val = rb_str_new2(return_str);
@@ -7210,7 +7200,7 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
7210
7200
 
7211
7201
  return ret_val;
7212
7202
  } else {
7213
- #ifdef UNICODE_SUPPORT_VERSION
7203
+ #ifdef UNICODE_SUPPORT_VERSION_H
7214
7204
  return _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( IBM_DB_G(__ruby_conn_err_msg), DB2_MAX_ERR_MSG_LEN * sizeof(SQLWCHAR) );
7215
7205
  #else
7216
7206
  return rb_str_new2(IBM_DB_G(__ruby_conn_err_msg));
@@ -7256,7 +7246,7 @@ VALUE ibm_db_stmt_errormsg(int argc, VALUE *argv, VALUE self)
7256
7246
  if (!NIL_P(stmt)) {
7257
7247
  Data_Get_Struct(stmt, stmt_handle, stmt_res);
7258
7248
 
7259
- #ifdef UNICODE_SUPPORT_VERSION
7249
+ #ifdef UNICODE_SUPPORT_VERSION_H
7260
7250
  return_str = ALLOC_N(SQLWCHAR, DB2_MAX_ERR_MSG_LEN + 1 );
7261
7251
  memset(return_str, '\0', (DB2_MAX_ERR_MSG_LEN + 1 ) * sizeof(SQLWCHAR) );
7262
7252
  #else
@@ -7272,7 +7262,7 @@ VALUE ibm_db_stmt_errormsg(int argc, VALUE *argv, VALUE self)
7272
7262
 
7273
7263
  stmt_res->errormsg_recno_tracker++;
7274
7264
 
7275
- #ifdef UNICODE_SUPPORT_VERSION
7265
+ #ifdef UNICODE_SUPPORT_VERSION_H
7276
7266
  ret_val = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( return_str, return_str_len );
7277
7267
  #else
7278
7268
  ret_val = rb_str_new2( return_str );
@@ -7281,7 +7271,7 @@ VALUE ibm_db_stmt_errormsg(int argc, VALUE *argv, VALUE self)
7281
7271
 
7282
7272
  return ret_val;
7283
7273
  } else {
7284
- #ifdef UNICODE_SUPPORT_VERSION
7274
+ #ifdef UNICODE_SUPPORT_VERSION_H
7285
7275
  return _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( IBM_DB_G(__ruby_stmt_err_msg), DB2_MAX_ERR_MSG_LEN * sizeof(SQLWCHAR) );
7286
7276
  #else
7287
7277
  return rb_str_new2(IBM_DB_G(__ruby_stmt_err_msg));
@@ -7340,7 +7330,7 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
7340
7330
  return Qnil;
7341
7331
  }
7342
7332
 
7343
- #ifdef UNICODE_SUPPORT_VERSION
7333
+ #ifdef UNICODE_SUPPORT_VERSION_H
7344
7334
  return_str = ALLOC_N(SQLWCHAR, SQL_SQLSTATE_SIZE + 1);
7345
7335
  memset(return_str, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
7346
7336
  #else
@@ -7357,7 +7347,7 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
7357
7347
 
7358
7348
  conn_res->error_recno_tracker++;
7359
7349
 
7360
- #ifdef UNICODE_SUPPORT_VERSION
7350
+ #ifdef UNICODE_SUPPORT_VERSION_H
7361
7351
  ret_val = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( return_str, SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR) );
7362
7352
  #else
7363
7353
  ret_val = rb_str_new2( return_str );
@@ -7366,7 +7356,7 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
7366
7356
 
7367
7357
  return ret_val;
7368
7358
  } else {
7369
- #ifdef UNICODE_SUPPORT_VERSION
7359
+ #ifdef UNICODE_SUPPORT_VERSION_H
7370
7360
  return _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( IBM_DB_G(__ruby_conn_err_state),
7371
7361
  SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR)
7372
7362
  );
@@ -7416,7 +7406,7 @@ VALUE ibm_db_stmt_error(int argc, VALUE *argv, VALUE self)
7416
7406
  if (!NIL_P(stmt)) {
7417
7407
  Data_Get_Struct(stmt, stmt_handle, stmt_res);
7418
7408
 
7419
- #ifdef UNICODE_SUPPORT_VERSION
7409
+ #ifdef UNICODE_SUPPORT_VERSION_H
7420
7410
  return_str = ALLOC_N(SQLWCHAR, SQL_SQLSTATE_SIZE + 1);
7421
7411
  memset(return_str, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
7422
7412
  #else
@@ -7433,7 +7423,7 @@ VALUE ibm_db_stmt_error(int argc, VALUE *argv, VALUE self)
7433
7423
 
7434
7424
  stmt_res->error_recno_tracker++;
7435
7425
 
7436
- #ifdef UNICODE_SUPPORT_VERSION
7426
+ #ifdef UNICODE_SUPPORT_VERSION_H
7437
7427
  ret_val = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( return_str, SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR) );
7438
7428
  #else
7439
7429
  ret_val = rb_str_new2( return_str );
@@ -7442,7 +7432,7 @@ VALUE ibm_db_stmt_error(int argc, VALUE *argv, VALUE self)
7442
7432
 
7443
7433
  return ret_val;
7444
7434
  } else {
7445
- #ifdef UNICODE_SUPPORT_VERSION
7435
+ #ifdef UNICODE_SUPPORT_VERSION_H
7446
7436
  return _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( IBM_DB_G(__ruby_stmt_err_state),
7447
7437
  SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR)
7448
7438
  );
@@ -7508,7 +7498,7 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
7508
7498
 
7509
7499
  if( conn_res->errorType != 1 ) {
7510
7500
  if( conn_res->ruby_error_msg != NULL ) {
7511
- #ifdef UNICODE_SUPPORT_VERSION
7501
+ #ifdef UNICODE_SUPPORT_VERSION_H
7512
7502
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( conn_res->ruby_error_msg, conn_res->ruby_error_msg_len );
7513
7503
  #else
7514
7504
  return_value = rb_str_new2( conn_res->ruby_error_msg );
@@ -7519,13 +7509,13 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
7519
7509
  } else {
7520
7510
 
7521
7511
  if( conn_res->errormsg_recno_tracker == 1 && conn_res->ruby_error_msg != NULL ) {
7522
- #ifdef UNICODE_SUPPORT_VERSION
7512
+ #ifdef UNICODE_SUPPORT_VERSION_H
7523
7513
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( conn_res->ruby_error_msg, conn_res->ruby_error_msg_len );
7524
7514
  #else
7525
7515
  return_value = rb_str_new2( conn_res->ruby_error_msg );
7526
7516
  #endif
7527
7517
  } else {
7528
- #ifdef UNICODE_SUPPORT_VERSION
7518
+ #ifdef UNICODE_SUPPORT_VERSION_H
7529
7519
  return_str = ALLOC_N(SQLWCHAR, DB2_MAX_ERR_MSG_LEN+1);
7530
7520
  memset(return_str, '\0', (DB2_MAX_ERR_MSG_LEN + 1) * sizeof(SQLWCHAR) );
7531
7521
  #else
@@ -7540,7 +7530,7 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
7540
7530
  conn_res->error_recno_tracker = conn_res->errormsg_recno_tracker;
7541
7531
  }
7542
7532
 
7543
- #ifdef UNICODE_SUPPORT_VERSION
7533
+ #ifdef UNICODE_SUPPORT_VERSION_H
7544
7534
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( return_str, return_str_len );
7545
7535
  #else
7546
7536
  return_value = rb_str_new2( return_str );
@@ -7553,13 +7543,13 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
7553
7543
  Data_Get_Struct(conn_or_stmt, stmt_handle, stmt_res);
7554
7544
 
7555
7545
  if( stmt_res->errormsg_recno_tracker == 1 && stmt_res->ruby_stmt_err_msg != NULL ) {
7556
- #ifdef UNICODE_SUPPORT_VERSION
7546
+ #ifdef UNICODE_SUPPORT_VERSION_H
7557
7547
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg, stmt_res->ruby_stmt_err_msg_len );
7558
7548
  #else
7559
7549
  return_value = rb_str_new2( stmt_res->ruby_stmt_err_msg );
7560
7550
  #endif
7561
7551
  } else {
7562
- #ifdef UNICODE_SUPPORT_VERSION
7552
+ #ifdef UNICODE_SUPPORT_VERSION_H
7563
7553
  return_str = ALLOC_N(SQLWCHAR, DB2_MAX_ERR_MSG_LEN + 1 );
7564
7554
  memset(return_str, '\0', (DB2_MAX_ERR_MSG_LEN + 1 ) * sizeof(SQLWCHAR) );
7565
7555
  #else
@@ -7574,7 +7564,7 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
7574
7564
  stmt_res->error_recno_tracker = stmt_res->errormsg_recno_tracker;
7575
7565
  }
7576
7566
 
7577
- #ifdef UNICODE_SUPPORT_VERSION
7567
+ #ifdef UNICODE_SUPPORT_VERSION_H
7578
7568
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( return_str, return_str_len );
7579
7569
  #else
7580
7570
  return_value = rb_str_new2( return_str );
@@ -7650,7 +7640,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
7650
7640
 
7651
7641
  if( conn_res->errorType != 1 ) {
7652
7642
  if( conn_res->ruby_error_state != NULL ) {
7653
- #ifdef UNICODE_SUPPORT_VERSION
7643
+ #ifdef UNICODE_SUPPORT_VERSION_H
7654
7644
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( conn_res->ruby_error_state,
7655
7645
  SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR)
7656
7646
  );
@@ -7663,7 +7653,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
7663
7653
  } else {
7664
7654
 
7665
7655
  if( conn_res->error_recno_tracker == 1 && conn_res->ruby_error_state != NULL ) {
7666
- #ifdef UNICODE_SUPPORT_VERSION
7656
+ #ifdef UNICODE_SUPPORT_VERSION_H
7667
7657
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( conn_res->ruby_error_state,
7668
7658
  SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR)
7669
7659
  );
@@ -7672,7 +7662,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
7672
7662
  #endif
7673
7663
  } else {
7674
7664
 
7675
- #ifdef UNICODE_SUPPORT_VERSION
7665
+ #ifdef UNICODE_SUPPORT_VERSION_H
7676
7666
  return_str = ALLOC_N(SQLWCHAR, SQL_SQLSTATE_SIZE + 1 );
7677
7667
  memset(return_str, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
7678
7668
  #else
@@ -7687,7 +7677,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
7687
7677
  conn_res->errormsg_recno_tracker = conn_res->error_recno_tracker;
7688
7678
  }
7689
7679
 
7690
- #ifdef UNICODE_SUPPORT_VERSION
7680
+ #ifdef UNICODE_SUPPORT_VERSION_H
7691
7681
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( return_str, SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR) );
7692
7682
  #else
7693
7683
  return_value = rb_str_new2( return_str );
@@ -7700,7 +7690,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
7700
7690
  Data_Get_Struct(conn_or_stmt, stmt_handle, stmt_res);
7701
7691
 
7702
7692
  if( stmt_res->error_recno_tracker == 1 && stmt_res->ruby_stmt_err_state != NULL ) {
7703
- #ifdef UNICODE_SUPPORT_VERSION
7693
+ #ifdef UNICODE_SUPPORT_VERSION_H
7704
7694
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_state,
7705
7695
  SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR)
7706
7696
  );
@@ -7709,7 +7699,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
7709
7699
  #endif
7710
7700
  } else {
7711
7701
 
7712
- #ifdef UNICODE_SUPPORT_VERSION
7702
+ #ifdef UNICODE_SUPPORT_VERSION_H
7713
7703
  return_str = ALLOC_N(SQLWCHAR, SQL_SQLSTATE_SIZE + 1 );
7714
7704
  memset(return_str, '\0', (SQL_SQLSTATE_SIZE + 1) * sizeof(SQLWCHAR) );
7715
7705
  #else
@@ -7723,7 +7713,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
7723
7713
  if(stmt_res->error_recno_tracker - stmt_res->errormsg_recno_tracker >= 1) {
7724
7714
  stmt_res->errormsg_recno_tracker = stmt_res->error_recno_tracker;
7725
7715
  }
7726
- #ifdef UNICODE_SUPPORT_VERSION
7716
+ #ifdef UNICODE_SUPPORT_VERSION_H
7727
7717
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( return_str,
7728
7718
  SQL_SQLSTATE_SIZE * sizeof(SQLWCHAR)
7729
7719
  );
@@ -7801,9 +7791,9 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
7801
7791
  nextresultparams->stmt_res = stmt_res;
7802
7792
  nextresultparams->new_hstmt = &new_hstmt;
7803
7793
 
7804
- #ifdef UNICODE_SUPPORT_VERSION
7805
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNextResult_helper, nextresultparams,
7806
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7794
+ #ifdef UNICODE_SUPPORT_VERSION_H
7795
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNextResult_helper, nextresultparams,
7796
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7807
7797
  rc = nextresultparams->rc;
7808
7798
  #else
7809
7799
  rc = _ruby_ibm_db_SQLNextResult_helper( nextresultparams );
@@ -7885,7 +7875,7 @@ VALUE ibm_db_num_fields(int argc, VALUE *argv, VALUE self)
7885
7875
  stmt_handle *stmt_res;
7886
7876
  int rc = 0;
7887
7877
 
7888
- #ifdef UNICODE_SUPPORT_VERSION
7878
+ #ifdef UNICODE_SUPPORT_VERSION_H
7889
7879
  char *err_str = NULL;
7890
7880
  #endif
7891
7881
 
@@ -7902,9 +7892,9 @@ VALUE ibm_db_num_fields(int argc, VALUE *argv, VALUE self)
7902
7892
  result_cols_args->stmt_res = stmt_res;
7903
7893
  result_cols_args->count = 0;
7904
7894
 
7905
- #ifdef UNICODE_SUPPORT_VERSION
7906
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNumResultCols_helper, result_cols_args,
7907
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7895
+ #ifdef UNICODE_SUPPORT_VERSION_H
7896
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLNumResultCols_helper, result_cols_args,
7897
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7908
7898
  rc = result_cols_args->rc;
7909
7899
  #else
7910
7900
  rc = _ruby_ibm_db_SQLNumResultCols_helper( result_cols_args );
@@ -7912,7 +7902,7 @@ VALUE ibm_db_num_fields(int argc, VALUE *argv, VALUE self)
7912
7902
 
7913
7903
  if ( rc == SQL_ERROR ) {
7914
7904
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 1 );
7915
- #ifdef UNICODE_SUPPORT_VERSION
7905
+ #ifdef UNICODE_SUPPORT_VERSION_H
7916
7906
  err_str = RSTRING_PTR( _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->ruby_stmt_err_msg,
7917
7907
  stmt_res->ruby_stmt_err_msg_len )
7918
7908
  );
@@ -7980,7 +7970,7 @@ VALUE ibm_db_num_rows(int argc, VALUE *argv, VALUE self)
7980
7970
 
7981
7971
  sql_row_count_args *row_count_args = NULL;
7982
7972
 
7983
- #ifdef UNICODE_SUPPORT_VERSION
7973
+ #ifdef UNICODE_SUPPORT_VERSION_H
7984
7974
  char *err_str = NULL;
7985
7975
  #endif
7986
7976
 
@@ -7995,9 +7985,9 @@ VALUE ibm_db_num_rows(int argc, VALUE *argv, VALUE self)
7995
7985
  row_count_args->stmt_res = stmt_res;
7996
7986
  row_count_args->count = 0;
7997
7987
 
7998
- #ifdef UNICODE_SUPPORT_VERSION
7999
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLRowCount_helper, row_count_args,
8000
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
7988
+ #ifdef UNICODE_SUPPORT_VERSION_H
7989
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLRowCount_helper, row_count_args,
7990
+ RUBY_UBF_IO, NULL );
8001
7991
  rc = row_count_args->rc;
8002
7992
  #else
8003
7993
  rc = _ruby_ibm_db_SQLRowCount_helper( row_count_args );
@@ -8006,7 +7996,7 @@ VALUE ibm_db_num_rows(int argc, VALUE *argv, VALUE self)
8006
7996
  if ( rc == SQL_ERROR ) {
8007
7997
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 1 );
8008
7998
 
8009
- #ifdef UNICODE_SUPPORT_VERSION
7999
+ #ifdef UNICODE_SUPPORT_VERSION_H
8010
8000
  err_str = RSTRING_PTR( _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->ruby_stmt_err_msg,
8011
8001
  stmt_res->ruby_stmt_err_msg_len )
8012
8002
  );
@@ -8041,7 +8031,7 @@ static int _ruby_ibm_db_get_column_by_name(stmt_handle *stmt_res, VALUE column,
8041
8031
  int rc;
8042
8032
  int index;
8043
8033
 
8044
- #ifdef UNICODE_SUPPORT_VERSION
8034
+ #ifdef UNICODE_SUPPORT_VERSION_H
8045
8035
  VALUE col_name = Qnil;
8046
8036
  #else
8047
8037
  char *col_name = NULL;
@@ -8052,9 +8042,9 @@ static int _ruby_ibm_db_get_column_by_name(stmt_handle *stmt_res, VALUE column,
8052
8042
  if ( stmt_res->column_info == NULL ) {
8053
8043
  if ( release_gil == 1 ) {
8054
8044
 
8055
- #ifdef UNICODE_SUPPORT_VERSION
8056
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_get_result_set_info, stmt_res,
8057
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8045
+ #ifdef UNICODE_SUPPORT_VERSION_H
8046
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_get_result_set_info, stmt_res,
8047
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8058
8048
  rc = stmt_res->rc;
8059
8049
  #else
8060
8050
  rc = _ruby_ibm_db_get_result_set_info( stmt_res );
@@ -8072,14 +8062,14 @@ static int _ruby_ibm_db_get_column_by_name(stmt_handle *stmt_res, VALUE column,
8072
8062
  if ( TYPE(column) == T_FIXNUM ) {
8073
8063
  col = FIX2LONG( column );
8074
8064
  } else if (RTEST( column )) {
8075
- #ifdef UNICODE_SUPPORT_VERSION
8065
+ #ifdef UNICODE_SUPPORT_VERSION_H
8076
8066
  col_name = _ruby_ibm_db_export_str_to_utf16( column );
8077
8067
  #else
8078
8068
  col_name = STR2CSTR( column );
8079
8069
  #endif
8080
8070
  }
8081
8071
 
8082
- #ifdef UNICODE_SUPPORT_VERSION
8072
+ #ifdef UNICODE_SUPPORT_VERSION_H
8083
8073
  if ( col_name == Qnil ) {
8084
8074
  #else
8085
8075
  if ( col_name == NULL ) {
@@ -8095,7 +8085,7 @@ static int _ruby_ibm_db_get_column_by_name(stmt_handle *stmt_res, VALUE column,
8095
8085
  /* should start from 0 */
8096
8086
  index = 0;
8097
8087
  while (index < stmt_res->num_columns) {
8098
- #ifdef UNICODE_SUPPORT_VERSION
8088
+ #ifdef UNICODE_SUPPORT_VERSION_H
8099
8089
  if ( rb_str_equal(_ruby_ibm_db_export_sqlwchar_to_utf16_rstr(stmt_res->column_info[index].name, stmt_res->column_info[index].name_length * sizeof(SQLWCHAR)), _ruby_ibm_db_export_str_to_utf16(col_name) ) ) {
8100
8090
  #else
8101
8091
  if (strcmp((char*)stmt_res->column_info[index].name,col_name) == 0) {
@@ -8151,7 +8141,7 @@ VALUE ibm_db_field_name(int argc, VALUE *argv, VALUE self)
8151
8141
  if ( col < 0 ) {
8152
8142
  return Qfalse;
8153
8143
  }
8154
- #ifdef UNICODE_SUPPORT_VERSION
8144
+ #ifdef UNICODE_SUPPORT_VERSION_H
8155
8145
  return _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->column_info[col].name, stmt_res->column_info[col].name_length * sizeof(SQLWCHAR));
8156
8146
  #else
8157
8147
  return rb_str_new2((char*)stmt_res->column_info[col].name);
@@ -8216,9 +8206,9 @@ VALUE ibm_db_field_display_size(int argc, VALUE *argv, VALUE self)
8216
8206
  colattr_args->col_num = col+1;
8217
8207
  colattr_args->FieldIdentifier = SQL_DESC_DISPLAY_SIZE;
8218
8208
 
8219
- #ifdef UNICODE_SUPPORT_VERSION
8220
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8221
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8209
+ #ifdef UNICODE_SUPPORT_VERSION_H
8210
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8211
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8222
8212
  rc = colattr_args->rc;
8223
8213
  #else
8224
8214
  rc = _ruby_ibm_db_SQLColAttributes_helper( colattr_args );
@@ -8467,7 +8457,7 @@ VALUE ibm_db_field_type(int argc, VALUE *argv, VALUE self)
8467
8457
  str_val = "string";
8468
8458
  break;
8469
8459
  }
8470
- #ifdef UNICODE_SUPPORT_VERSION
8460
+ #ifdef UNICODE_SUPPORT_VERSION_H
8471
8461
  return _ruby_ibm_db_export_char_to_utf8_rstr(str_val);
8472
8462
  #else
8473
8463
  return rb_str_new2( str_val );
@@ -8537,9 +8527,9 @@ VALUE ibm_db_field_width(int argc, VALUE *argv, VALUE self)
8537
8527
  colattr_args->col_num = col+1;
8538
8528
  colattr_args->FieldIdentifier = SQL_DESC_LENGTH;
8539
8529
 
8540
- #ifdef UNICODE_SUPPORT_VERSION
8530
+ #ifdef UNICODE_SUPPORT_VERSION_H
8541
8531
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLColAttributes_helper, colattr_args,
8542
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
8532
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res);
8543
8533
  rc = colattr_args->rc;
8544
8534
  #else
8545
8535
  rc = _ruby_ibm_db_SQLColAttributes_helper( colattr_args );
@@ -8639,9 +8629,9 @@ VALUE ibm_db_rollback(int argc, VALUE *argv, VALUE self)
8639
8629
  end_X_args->hdbc = &(conn_res->hdbc);
8640
8630
  end_X_args->handleType = SQL_HANDLE_DBC;
8641
8631
  end_X_args->completionType = SQL_ROLLBACK; /*Remeber you are Rollingback the transaction*/
8642
- #ifdef UNICODE_SUPPORT_VERSION
8632
+ #ifdef UNICODE_SUPPORT_VERSION_H
8643
8633
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_SQLEndTran, end_X_args,
8644
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
8634
+ RUBY_UBF_IO, NULL);
8645
8635
  rc = end_X_args->rc;
8646
8636
  #else
8647
8637
  rc = _ruby_ibm_db_SQLEndTran( end_X_args );
@@ -8833,7 +8823,7 @@ int isNullLOB(VALUE *return_value,int i,stmt_handle *stmt_res,int op)
8833
8823
  VALUE colName;
8834
8824
  if (stmt_res->column_info[i].loc_ind == SQL_NULL_DATA) {
8835
8825
  if ( op & FETCH_ASSOC ) {
8836
- #ifdef UNICODE_SUPPORT_VERSION
8826
+ #ifdef UNICODE_SUPPORT_VERSION_H
8837
8827
  colName = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->column_info[i].name, stmt_res->column_info[i].name_length * sizeof(SQLWCHAR) );
8838
8828
  #else
8839
8829
  colName = rb_str_new2( (char*)stmt_res->column_info[i].name );
@@ -8885,7 +8875,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8885
8875
  if ( stmt_res->column_info == NULL ) {
8886
8876
  if (_ruby_ibm_db_get_result_set_info(stmt_res)<0) {
8887
8877
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
8888
- #ifdef UNICODE_SUPPORT_VERSION
8878
+ #ifdef UNICODE_SUPPORT_VERSION_H
8889
8879
  *(data->error) = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: "),
8890
8880
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
8891
8881
  stmt_res->ruby_stmt_err_msg_len)
@@ -8894,7 +8884,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8894
8884
  *(data->error) = rb_str_cat2(rb_str_new2("Column information cannot be retrieved: "), stmt_res->ruby_stmt_err_msg );
8895
8885
  #endif
8896
8886
  } else {
8897
- #ifdef UNICODE_SUPPORT_VERSION
8887
+ #ifdef UNICODE_SUPPORT_VERSION_H
8898
8888
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: <error message could not be retrieved>");
8899
8889
  #else
8900
8890
  *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
@@ -8906,7 +8896,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8906
8896
  }
8907
8897
 
8908
8898
  if(col_num < 0 || col_num >= stmt_res->num_columns) {
8909
- #ifdef UNICODE_SUPPORT_VERSION
8899
+ #ifdef UNICODE_SUPPORT_VERSION_H
8910
8900
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Column ordinal out of range" );
8911
8901
  #else
8912
8902
  *(data->error) = rb_str_new2("Column ordinal out of range" );
@@ -8930,7 +8920,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8930
8920
  case SQL_WLONGVARCHAR:
8931
8921
  in_length = stmt_res->column_info[col_num].size + 1;
8932
8922
 
8933
- #ifdef UNICODE_SUPPORT_VERSION
8923
+ #ifdef UNICODE_SUPPORT_VERSION_H
8934
8924
  out_ptr = (SQLPOINTER)ALLOC_N(SQLWCHAR,in_length);
8935
8925
  memset(out_ptr, '\0', in_length * sizeof(SQLWCHAR) );
8936
8926
  #else
@@ -8959,7 +8949,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8959
8949
  return Qnil;
8960
8950
  }
8961
8951
 
8962
- #ifdef UNICODE_SUPPORT_VERSION
8952
+ #ifdef UNICODE_SUPPORT_VERSION_H
8963
8953
  rc = _ruby_ibm_db_get_data(stmt_res, col_num+1, SQL_C_WCHAR, out_ptr, in_length * sizeof(SQLWCHAR) , &out_length);
8964
8954
  #else
8965
8955
  rc = _ruby_ibm_db_get_data(stmt_res, col_num+1, SQL_C_CHAR, out_ptr, in_length, &out_length);
@@ -8974,7 +8964,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
8974
8964
  data->return_value = Qnil;
8975
8965
  return Qnil;
8976
8966
  } else {
8977
- #ifdef UNICODE_SUPPORT_VERSION
8967
+ #ifdef UNICODE_SUPPORT_VERSION_H
8978
8968
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(out_ptr, out_length);
8979
8969
  #else
8980
8970
  return_value = rb_str_new((char*)out_ptr, out_length);
@@ -9076,7 +9066,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9076
9066
  return Qnil;
9077
9067
  }
9078
9068
 
9079
- #ifdef UNICODE_SUPPORT_VERSION
9069
+ #ifdef UNICODE_SUPPORT_VERSION_H
9080
9070
  out_ptr = (char*)ALLOC_N(SQLWCHAR,in_length+1);
9081
9071
  memset(out_ptr, '\0', (in_length + 1) * sizeof(SQLWCHAR) );
9082
9072
  #else
@@ -9090,7 +9080,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9090
9080
  return Qnil;
9091
9081
  }
9092
9082
 
9093
- #ifdef UNICODE_SUPPORT_VERSION
9083
+ #ifdef UNICODE_SUPPORT_VERSION_H
9094
9084
  rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, SQL_C_WCHAR, out_ptr, in_length, (in_length + 1) * sizeof(SQLWCHAR) , &out_length);
9095
9085
  #else
9096
9086
  rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, SQL_C_CHAR, (void*)out_ptr, in_length, in_length+1, &out_length);
@@ -9101,7 +9091,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9101
9091
  return Qfalse;
9102
9092
  }
9103
9093
 
9104
- #ifdef UNICODE_SUPPORT_VERSION
9094
+ #ifdef UNICODE_SUPPORT_VERSION_H
9105
9095
  return_value = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(out_ptr, out_length);
9106
9096
  #else
9107
9097
  return_value = rb_str_new2(out_ptr);
@@ -9201,7 +9191,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
9201
9191
  return Qfalse;
9202
9192
  }
9203
9193
 
9204
- #ifdef UNICODE_SUPPORT_VERSION
9194
+ #ifdef UNICODE_SUPPORT_VERSION_H
9205
9195
  return_value = _ruby_ibm_db_export_sqlchar_to_utf8_rstr(out_ptr, out_length);
9206
9196
  #else
9207
9197
  return_value = rb_str_new((char*)out_ptr,out_length);
@@ -9261,9 +9251,9 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
9261
9251
  if ( !NIL_P( stmt ) ) {
9262
9252
  Data_Get_Struct(stmt, stmt_handle, result_args->stmt_res);
9263
9253
 
9264
- #ifdef UNICODE_SUPPORT_VERSION
9265
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_result_helper, result_args,
9266
- (void *)_ruby_ibm_db_Statement_level_UBF, result_args->stmt_res );
9254
+ #ifdef UNICODE_SUPPORT_VERSION_H
9255
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_result_helper, result_args,
9256
+ (void *)_ruby_ibm_db_Statement_level_UBF, result_args->stmt_res );
9267
9257
  ret_val = result_args->return_value;
9268
9258
  #else
9269
9259
  ret_val = _ruby_ibm_db_result_helper( result_args );
@@ -9325,7 +9315,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9325
9315
  if ( stmt_res->column_info == NULL ) {
9326
9316
  if (_ruby_ibm_db_get_result_set_info(stmt_res)<0) {
9327
9317
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
9328
- #ifdef UNICODE_SUPPORT_VERSION
9318
+ #ifdef UNICODE_SUPPORT_VERSION_H
9329
9319
  *(data->error) = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: "),
9330
9320
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->ruby_stmt_err_msg,
9331
9321
  stmt_res->ruby_stmt_err_msg_len)
@@ -9334,7 +9324,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9334
9324
  *(data->error) = rb_str_cat2(rb_str_new2("Column information cannot be retrieved: "), stmt_res->ruby_stmt_err_msg );
9335
9325
  #endif
9336
9326
  } else {
9337
- #ifdef UNICODE_SUPPORT_VERSION
9327
+ #ifdef UNICODE_SUPPORT_VERSION_H
9338
9328
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: <error message could not be retrieved>");
9339
9329
  #else
9340
9330
  *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
@@ -9350,7 +9340,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9350
9340
  rc = _ruby_ibm_db_bind_column_helper(stmt_res);
9351
9341
  if ( rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO ) {
9352
9342
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
9353
- #ifdef UNICODE_SUPPORT_VERSION
9343
+ #ifdef UNICODE_SUPPORT_VERSION_H
9354
9344
  *(data->error) = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Column binding cannot be done: "),
9355
9345
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->ruby_stmt_err_msg,
9356
9346
  stmt_res->ruby_stmt_err_msg_len)
@@ -9359,7 +9349,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9359
9349
  *(data->error) = rb_str_cat2(rb_str_new2("Column binding cannot be done: "), stmt_res->ruby_stmt_err_msg );
9360
9350
  #endif
9361
9351
  } else {
9362
- #ifdef UNICODE_SUPPORT_VERSION
9352
+ #ifdef UNICODE_SUPPORT_VERSION_H
9363
9353
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Column binding cannot be done: <error message could not be retrieved>");
9364
9354
  #else
9365
9355
  *(data->error) = rb_str_new2("Column binding cannot be done: <error message could not be retrieved>");
@@ -9410,7 +9400,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9410
9400
  }
9411
9401
  #endif /*PASE*/
9412
9402
  } else if (data->arg_count == 2 && row_number < 0) {
9413
- #ifdef UNICODE_SUPPORT_VERSION
9403
+ #ifdef UNICODE_SUPPORT_VERSION_H
9414
9404
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Requested row number must be a positive value");
9415
9405
  #else
9416
9406
  *(data->error) = rb_str_new2("Requested row number must be a positive value");
@@ -9439,7 +9429,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9439
9429
  } else if ( rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
9440
9430
  _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
9441
9431
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
9442
- #ifdef UNICODE_SUPPORT_VERSION
9432
+ #ifdef UNICODE_SUPPORT_VERSION_H
9443
9433
  *(data->error) = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Fetch Failure: "),
9444
9434
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
9445
9435
  stmt_res->ruby_stmt_err_msg_len )
@@ -9448,7 +9438,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9448
9438
  *(data->error) = rb_str_cat2(rb_str_new2("Fetch Failure: "), stmt_res->ruby_stmt_err_msg );
9449
9439
  #endif
9450
9440
  } else {
9451
- #ifdef UNICODE_SUPPORT_VERSION
9441
+ #ifdef UNICODE_SUPPORT_VERSION_H
9452
9442
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Fetch Failure: <error message could not be retrieved>");
9453
9443
  #else
9454
9444
  *(data->error) = rb_str_new2("Fetch Failure: <error message could not be retrieved>");
@@ -9471,14 +9461,14 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9471
9461
 
9472
9462
  switch(stmt_res->s_case_mode) {
9473
9463
  case CASE_LOWER:
9474
- #ifdef UNICODE_SUPPORT_VERSION
9464
+ #ifdef UNICODE_SUPPORT_VERSION_H
9475
9465
  strtolower((char*)stmt_res->column_info[i].name, stmt_res->column_info[i].name_length * sizeof(SQLWCHAR));
9476
9466
  #else
9477
9467
  strtolower((char*)stmt_res->column_info[i].name, strlen((char*)stmt_res->column_info[i].name));
9478
9468
  #endif
9479
9469
  break;
9480
9470
  case CASE_UPPER:
9481
- #ifdef UNICODE_SUPPORT_VERSION
9471
+ #ifdef UNICODE_SUPPORT_VERSION_H
9482
9472
  strtoupper((char*)stmt_res->column_info[i].name, stmt_res->column_info[i].name_length * sizeof(SQLWCHAR) );
9483
9473
  #else
9484
9474
  strtoupper((char*)stmt_res->column_info[i].name, strlen((char*)stmt_res->column_info[i].name));
@@ -9489,7 +9479,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9489
9479
  break;
9490
9480
  }
9491
9481
 
9492
- #ifdef UNICODE_SUPPORT_VERSION
9482
+ #ifdef UNICODE_SUPPORT_VERSION_H
9493
9483
  colName = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->column_info[i].name, stmt_res->column_info[i].name_length * sizeof(SQLWCHAR) );
9494
9484
  #else
9495
9485
  colName = rb_str_new2((char*)stmt_res->column_info[i].name);
@@ -9516,20 +9506,20 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9516
9506
  case SQL_LONGVARCHAR:
9517
9507
  case SQL_WLONGVARCHAR:
9518
9508
  if ( op & FETCH_ASSOC ) {
9519
- #ifdef UNICODE_SUPPORT_VERSION
9509
+ #ifdef UNICODE_SUPPORT_VERSION_H
9520
9510
  rb_hash_aset(return_value, colName, _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(row_data->str_val, out_length ));
9521
9511
  #else
9522
9512
  rb_hash_aset(return_value, colName, rb_str_new((char *)row_data->str_val, out_length));
9523
9513
  #endif
9524
9514
  }
9525
9515
  if ( op == FETCH_INDEX ) {
9526
- #ifdef UNICODE_SUPPORT_VERSION
9516
+ #ifdef UNICODE_SUPPORT_VERSION_H
9527
9517
  rb_ary_store(return_value, i, _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(row_data->str_val, out_length ));
9528
9518
  #else
9529
9519
  rb_ary_store(return_value, i, rb_str_new((char *)row_data->str_val, out_length));
9530
9520
  #endif
9531
9521
  } else if ( op == FETCH_BOTH ) {
9532
- #ifdef UNICODE_SUPPORT_VERSION
9522
+ #ifdef UNICODE_SUPPORT_VERSION_H
9533
9523
  rb_hash_aset(return_value, INT2NUM(i), _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(row_data->str_val, out_length ));
9534
9524
  #else
9535
9525
  rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char *)row_data->str_val, out_length));
@@ -9600,7 +9590,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9600
9590
  return Qnil;
9601
9591
  }
9602
9592
 
9603
- strcpy(tmpStr, "BigDecimal.new(\'");
9593
+ strcpy(tmpStr, "BigDecimal(\'");
9604
9594
  strcat(tmpStr, row_data->str_val);
9605
9595
  strcat(tmpStr, "\')");
9606
9596
 
@@ -9772,7 +9762,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9772
9762
 
9773
9763
  if ( rc == SQL_ERROR ) {
9774
9764
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
9775
- #ifdef UNICODE_SUPPORT_VERSION
9765
+ #ifdef UNICODE_SUPPORT_VERSION_H
9776
9766
  *(data->error) = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Failed to Determine XML Size: "),
9777
9767
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
9778
9768
  stmt_res->ruby_stmt_err_msg_len)
@@ -9781,7 +9771,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9781
9771
  *(data->error) = rb_str_cat2(rb_str_new2("Failed to Determine XML Size: "), stmt_res->ruby_stmt_err_msg );
9782
9772
  #endif
9783
9773
  } else {
9784
- #ifdef UNICODE_SUPPORT_VERSION
9774
+ #ifdef UNICODE_SUPPORT_VERSION_H
9785
9775
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Failed to Determine XML Size: <error message could not be retrieved>");
9786
9776
  #else
9787
9777
  *(data->error) = rb_str_new2("Failed to Determine XML Size: <error message could not be retrieved>");
@@ -9820,20 +9810,20 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9820
9810
  }
9821
9811
 
9822
9812
  if ( op & FETCH_ASSOC ) {
9823
- #ifdef UNICODE_SUPPORT_VERSION
9813
+ #ifdef UNICODE_SUPPORT_VERSION_H
9824
9814
  rb_hash_aset(return_value, colName, _ruby_ibm_db_export_sqlchar_to_utf8_rstr( (SQLCHAR *) out_ptr, out_length));
9825
9815
  #else
9826
9816
  rb_hash_aset(return_value, colName, rb_str_new((char *)out_ptr, out_length));
9827
9817
  #endif
9828
9818
  }
9829
9819
  if ( op == FETCH_INDEX ) {
9830
- #ifdef UNICODE_SUPPORT_VERSION
9820
+ #ifdef UNICODE_SUPPORT_VERSION_H
9831
9821
  rb_ary_store(return_value, i, _ruby_ibm_db_export_sqlchar_to_utf8_rstr( (SQLCHAR *) out_ptr, out_length));
9832
9822
  #else
9833
9823
  rb_ary_store(return_value, i, rb_str_new((char *)out_ptr, out_length));
9834
9824
  #endif
9835
9825
  } else if ( op == FETCH_BOTH ) {
9836
- #ifdef UNICODE_SUPPORT_VERSION
9826
+ #ifdef UNICODE_SUPPORT_VERSION_H
9837
9827
  rb_hash_aset(return_value, INT2NUM(i), _ruby_ibm_db_export_sqlchar_to_utf8_rstr( (SQLCHAR *) out_ptr, out_length));
9838
9828
  #else
9839
9829
  rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char *)out_ptr, out_length));
@@ -9866,7 +9856,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9866
9856
  }
9867
9857
  } else {
9868
9858
  if (rc == SQL_ERROR) tmp_length = 0;
9869
- #ifdef UNICODE_SUPPORT_VERSION
9859
+ #ifdef UNICODE_SUPPORT_VERSION_H
9870
9860
  out_ptr = (SQLPOINTER)ALLOC_N(SQLWCHAR, tmp_length + 1);
9871
9861
  memset(out_ptr, '\0', (tmp_length+1) * sizeof(SQLWCHAR));
9872
9862
  #else
@@ -9881,7 +9871,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9881
9871
  return Qnil;
9882
9872
  }
9883
9873
 
9884
- #ifdef UNICODE_SUPPORT_VERSION
9874
+ #ifdef UNICODE_SUPPORT_VERSION_H
9885
9875
  rc = _ruby_ibm_db_get_data2(stmt_res, i+1, SQL_C_WCHAR, out_ptr, tmp_length , (tmp_length + 1) * sizeof(SQLWCHAR) , &out_length);
9886
9876
  #else
9887
9877
  rc = _ruby_ibm_db_get_data2(stmt_res, i+1, SQL_C_CHAR, out_ptr, tmp_length, tmp_length+1, &out_length);
@@ -9895,20 +9885,20 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
9895
9885
  }
9896
9886
 
9897
9887
  if ( op & FETCH_ASSOC ) {
9898
- #ifdef UNICODE_SUPPORT_VERSION
9888
+ #ifdef UNICODE_SUPPORT_VERSION_H
9899
9889
  rb_hash_aset(return_value, colName, _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(out_ptr, out_length));
9900
9890
  #else
9901
9891
  rb_hash_aset(return_value, colName, rb_str_new((char*)out_ptr, out_length));
9902
9892
  #endif
9903
9893
  }
9904
9894
  if ( op == FETCH_INDEX ) {
9905
- #ifdef UNICODE_SUPPORT_VERSION
9895
+ #ifdef UNICODE_SUPPORT_VERSION_H
9906
9896
  rb_ary_store(return_value, i, _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(out_ptr, out_length));
9907
9897
  #else
9908
9898
  rb_ary_store(return_value, i, rb_str_new((char*)out_ptr, out_length));
9909
9899
  #endif
9910
9900
  } else if ( op == FETCH_BOTH ) {
9911
- #ifdef UNICODE_SUPPORT_VERSION
9901
+ #ifdef UNICODE_SUPPORT_VERSION_H
9912
9902
  rb_hash_aset(return_value, INT2NUM(i), _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(out_ptr, out_length));
9913
9903
  #else
9914
9904
  rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char*)out_ptr, out_length));
@@ -9949,7 +9939,7 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
9949
9939
  if ( stmt_res->column_info == NULL ) {
9950
9940
  if (_ruby_ibm_db_get_result_set_info(stmt_res)<0) {
9951
9941
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
9952
- #ifdef UNICODE_SUPPORT_VERSION
9942
+ #ifdef UNICODE_SUPPORT_VERSION_H
9953
9943
  *(data->error) = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: "),
9954
9944
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
9955
9945
  stmt_res->ruby_stmt_err_msg_len)
@@ -9958,7 +9948,7 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
9958
9948
  *(data->error) = rb_str_cat2(rb_str_new2("Column information cannot be retrieved: "), stmt_res->ruby_stmt_err_msg );
9959
9949
  #endif
9960
9950
  } else {
9961
- #ifdef UNICODE_SUPPORT_VERSION
9951
+ #ifdef UNICODE_SUPPORT_VERSION_H
9962
9952
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: <error message could not be retrieved>");
9963
9953
  #else
9964
9954
  *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
@@ -9996,7 +9986,7 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
9996
9986
  }
9997
9987
  #endif /*PASE*/
9998
9988
  } else if (data->arg_count == 2 && row_number < 0) {
9999
- #ifdef UNICODE_SUPPORT_VERSION
9989
+ #ifdef UNICODE_SUPPORT_VERSION_H
10000
9990
  *(data->error) = _ruby_ibm_db_export_char_to_utf8_rstr("Requested row number must be a positive value");
10001
9991
  #else
10002
9992
  *(data->error) = rb_str_new2("Requested row number must be a positive value");
@@ -10082,9 +10072,9 @@ VALUE ibm_db_fetch_row(int argc, VALUE *argv, VALUE self)
10082
10072
  helper_args->arg_count = argc;
10083
10073
  helper_args->error = &error;
10084
10074
 
10085
- #ifdef UNICODE_SUPPORT_VERSION
10075
+ #ifdef UNICODE_SUPPORT_VERSION_H
10086
10076
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_fetch_row_helper, helper_args,
10087
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10077
+ RUBY_UBF_IO, NULL );
10088
10078
  ret_val = helper_args->return_value;
10089
10079
  #else
10090
10080
  ret_val = _ruby_ibm_db_fetch_row_helper( helper_args );
@@ -10145,7 +10135,7 @@ VALUE ibm_db_result_cols(int argc, VALUE *argv, VALUE self) {
10145
10135
  if ( stmt_res->column_info == NULL ) {
10146
10136
  if (_ruby_ibm_db_get_result_set_info(stmt_res)<0) {
10147
10137
  if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
10148
- #ifdef UNICODE_SUPPORT_VERSION
10138
+ #ifdef UNICODE_SUPPORT_VERSION_H
10149
10139
  error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: "),
10150
10140
  _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->ruby_stmt_err_msg,
10151
10141
  stmt_res->ruby_stmt_err_msg_len)
@@ -10154,7 +10144,7 @@ VALUE ibm_db_result_cols(int argc, VALUE *argv, VALUE self) {
10154
10144
  error = rb_str_cat2(rb_str_new2("Column information cannot be retrieved: "), stmt_res->ruby_stmt_err_msg );
10155
10145
  #endif
10156
10146
  } else {
10157
- #ifdef UNICODE_SUPPORT_VERSION
10147
+ #ifdef UNICODE_SUPPORT_VERSION_H
10158
10148
  error = _ruby_ibm_db_export_char_to_utf8_rstr("Column information cannot be retrieved: <error message could not be retrieved>");
10159
10149
  #else
10160
10150
  error = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
@@ -10169,14 +10159,14 @@ VALUE ibm_db_result_cols(int argc, VALUE *argv, VALUE self) {
10169
10159
  for (index=0; index<stmt_res->num_columns; index++) {
10170
10160
  switch(stmt_res->s_case_mode) {
10171
10161
  case CASE_LOWER:
10172
- #ifdef UNICODE_SUPPORT_VERSION
10162
+ #ifdef UNICODE_SUPPORT_VERSION_H
10173
10163
  strtolower((char*)stmt_res->column_info[index].name, stmt_res->column_info[index].name_length * sizeof(SQLWCHAR));
10174
10164
  #else
10175
10165
  strtolower((char*)stmt_res->column_info[index].name, strlen((char*)stmt_res->column_info[index].name));
10176
10166
  #endif
10177
10167
  break;
10178
10168
  case CASE_UPPER:
10179
- #ifdef UNICODE_SUPPORT_VERSION
10169
+ #ifdef UNICODE_SUPPORT_VERSION_H
10180
10170
  strtoupper((char*)stmt_res->column_info[index].name, stmt_res->column_info[index].name_length * sizeof(SQLWCHAR) );
10181
10171
  #else
10182
10172
  strtoupper((char*)stmt_res->column_info[index].name, strlen((char*)stmt_res->column_info[index].name));
@@ -10186,7 +10176,7 @@ VALUE ibm_db_result_cols(int argc, VALUE *argv, VALUE self) {
10186
10176
  default:
10187
10177
  break;
10188
10178
  }
10189
- #ifdef UNICODE_SUPPORT_VERSION
10179
+ #ifdef UNICODE_SUPPORT_VERSION_H
10190
10180
  colName = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(stmt_res->column_info[index].name, stmt_res->column_info[index].name_length * sizeof(SQLWCHAR) );
10191
10181
  #else
10192
10182
  colName = rb_str_new2((char*)stmt_res->column_info[index].name);
@@ -10251,9 +10241,9 @@ VALUE ibm_db_fetch_assoc(int argc, VALUE *argv, VALUE self) {
10251
10241
  helper_args->error = &error;
10252
10242
  helper_args->funcType = FETCH_ASSOC;
10253
10243
 
10254
- #ifdef UNICODE_SUPPORT_VERSION
10255
- ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10256
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10244
+ #ifdef UNICODE_SUPPORT_VERSION_H
10245
+ ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10246
+ RUBY_UBF_IO, NULL );
10257
10247
  ret_val = helper_args->return_value;
10258
10248
 
10259
10249
  #else
@@ -10340,9 +10330,9 @@ VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self)
10340
10330
  helper_args->error = &error;
10341
10331
  helper_args->funcType = FETCH_ASSOC;
10342
10332
 
10343
- #ifdef UNICODE_SUPPORT_VERSION
10333
+ #ifdef UNICODE_SUPPORT_VERSION_H
10344
10334
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10345
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10335
+ (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10346
10336
  row_res->hash = helper_args->return_value;
10347
10337
  #else
10348
10338
  row_res->hash = _ruby_ibm_db_bind_fetch_helper( helper_args );
@@ -10422,17 +10412,15 @@ VALUE ibm_db_fetch_array(int argc, VALUE *argv, VALUE self)
10422
10412
  helper_args->arg_count = argc;
10423
10413
  helper_args->error = &error;
10424
10414
  helper_args->funcType = FETCH_INDEX;
10425
-
10426
10415
  //Call without thread API to avoid the Thread lock.
10427
10416
  ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
10428
-
10429
- //#ifdef UNICODE_SUPPORT_VERSION
10430
- //ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10431
- // (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10432
- // ret_val = helper_args->return_value;
10433
- //
10417
+ //#ifdef UNICODE_SUPPORT_VERSION_H
10418
+ //ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10419
+ // RUBY_UBF_IO, NULL );
10420
+ //ret_val = helper_args->return_value;
10421
+
10434
10422
  //#else
10435
- // ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
10423
+ //ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
10436
10424
  //#endif
10437
10425
 
10438
10426
  /*Free Memory Allocated*/
@@ -10504,9 +10492,9 @@ VALUE ibm_db_fetch_both(int argc, VALUE *argv, VALUE self)
10504
10492
  helper_args->error = &error;
10505
10493
  helper_args->funcType = FETCH_BOTH;
10506
10494
 
10507
- #ifdef UNICODE_SUPPORT_VERSION
10495
+ #ifdef UNICODE_SUPPORT_VERSIO
10508
10496
  ibm_Ruby_Thread_Call ( (void *)_ruby_ibm_db_bind_fetch_helper, helper_args,
10509
- (void *)_ruby_ibm_db_Statement_level_UBF, stmt_res );
10497
+ RUBY_UBF_IO, NULL );
10510
10498
  ret_val = helper_args->return_value;
10511
10499
  #else
10512
10500
  ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
@@ -10604,7 +10592,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10604
10592
  int rc = 0;
10605
10593
  SQLSMALLINT out_length = 0;
10606
10594
 
10607
- #ifndef UNICODE_SUPPORT_VERSION
10595
+ #ifndef UNICODE_SUPPORT_VERSION_H
10608
10596
  char buffer11[11];
10609
10597
  char buffer255[255];
10610
10598
  char buffer3k[3072]; /*Informix server returns SQL_KEYWORDS data, which requires 2608*/
@@ -10637,7 +10625,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10637
10625
  return Qfalse;
10638
10626
  } else {
10639
10627
 
10640
- #ifdef UNICODE_SUPPORT_VERSION
10628
+ #ifdef UNICODE_SUPPORT_VERSION_H
10641
10629
  rb_iv_set(return_value, "@DBMS_NAME", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
10642
10630
  #else
10643
10631
  rb_iv_set(return_value, "@DBMS_NAME", rb_str_new2(buffer255));
@@ -10657,7 +10645,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10657
10645
  getInfo_args->return_value = Qfalse;
10658
10646
  return Qfalse;
10659
10647
  } else {
10660
- #ifdef UNICODE_SUPPORT_VERSION
10648
+ #ifdef UNICODE_SUPPORT_VERSION_H
10661
10649
  rb_iv_set(return_value, "@DBMS_VER", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer11, out_length));
10662
10650
  #else
10663
10651
  rb_iv_set(return_value, "@DBMS_VER", rb_str_new2(buffer11));
@@ -10697,7 +10685,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10697
10685
  getInfo_args->return_value = Qfalse;
10698
10686
  return Qfalse;
10699
10687
  } else {
10700
- #ifdef UNICODE_SUPPORT_VERSION
10688
+ #ifdef UNICODE_SUPPORT_VERSION_H
10701
10689
  rb_iv_set(return_value, "@DB_NAME", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
10702
10690
  #else
10703
10691
  rb_iv_set(return_value, "@DB_NAME", rb_str_new2(buffer255));
@@ -10719,7 +10707,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10719
10707
  getInfo_args->return_value = Qfalse;
10720
10708
  return Qfalse;
10721
10709
  } else {
10722
- #ifdef UNICODE_SUPPORT_VERSION
10710
+ #ifdef UNICODE_SUPPORT_VERSION_H
10723
10711
  rb_iv_set(return_value, "@INST_NAME", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
10724
10712
  #else
10725
10713
  rb_iv_set(return_value, "@INST_NAME", rb_str_new2(buffer255));
@@ -10740,7 +10728,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10740
10728
  getInfo_args->return_value = Qfalse;
10741
10729
  return Qfalse;
10742
10730
  } else {
10743
- #ifdef UNICODE_SUPPORT_VERSION
10731
+ #ifdef UNICODE_SUPPORT_VERSION_H
10744
10732
  rb_iv_set(return_value, "@SPECIAL_CHARS", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
10745
10733
  #else
10746
10734
  rb_iv_set(return_value, "@SPECIAL_CHARS", rb_str_new2(buffer255));
@@ -10763,7 +10751,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10763
10751
  return Qfalse;
10764
10752
  } else {
10765
10753
  VALUE keywordsStr, keywordsArray;
10766
- #ifdef UNICODE_SUPPORT_VERSION
10754
+ #ifdef UNICODE_SUPPORT_VERSION_H
10767
10755
  keywordsStr = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer3k, out_length);
10768
10756
  keywordsArray = rb_str_split(keywordsStr, RSTRING_PTR(_ruby_ibm_db_export_char_to_utf8_rstr(",")) );
10769
10757
  #else
@@ -10789,35 +10777,35 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10789
10777
  } else {
10790
10778
  VALUE dft_isolation = Qnil;
10791
10779
  if( bitmask & SQL_TXN_READ_UNCOMMITTED ) {
10792
- #ifdef UNICODE_SUPPORT_VERSION
10780
+ #ifdef UNICODE_SUPPORT_VERSION_H
10793
10781
  dft_isolation = _ruby_ibm_db_export_char_to_utf8_rstr("UR");
10794
10782
  #else
10795
10783
  dft_isolation = rb_str_new2("UR");
10796
10784
  #endif
10797
10785
  }
10798
10786
  if( bitmask & SQL_TXN_READ_COMMITTED ) {
10799
- #ifdef UNICODE_SUPPORT_VERSION
10787
+ #ifdef UNICODE_SUPPORT_VERSION_H
10800
10788
  dft_isolation = _ruby_ibm_db_export_char_to_utf8_rstr("CS");
10801
10789
  #else
10802
10790
  dft_isolation = rb_str_new2("CS");
10803
10791
  #endif
10804
10792
  }
10805
10793
  if( bitmask & SQL_TXN_REPEATABLE_READ ) {
10806
- #ifdef UNICODE_SUPPORT_VERSION
10794
+ #ifdef UNICODE_SUPPORT_VERSION_H
10807
10795
  dft_isolation = _ruby_ibm_db_export_char_to_utf8_rstr("RS");
10808
10796
  #else
10809
10797
  dft_isolation = rb_str_new2("RS");
10810
10798
  #endif
10811
10799
  }
10812
10800
  if( bitmask & SQL_TXN_SERIALIZABLE ) {
10813
- #ifdef UNICODE_SUPPORT_VERSION
10801
+ #ifdef UNICODE_SUPPORT_VERSION_H
10814
10802
  dft_isolation = _ruby_ibm_db_export_char_to_utf8_rstr("RR");
10815
10803
  #else
10816
10804
  dft_isolation = rb_str_new2("RR");
10817
10805
  #endif
10818
10806
  }
10819
10807
  if( bitmask & SQL_TXN_NOCOMMIT ) {
10820
- #ifdef UNICODE_SUPPORT_VERSION
10808
+ #ifdef UNICODE_SUPPORT_VERSION_H
10821
10809
  dft_isolation = _ruby_ibm_db_export_char_to_utf8_rstr("NC");
10822
10810
  #else
10823
10811
  dft_isolation = rb_str_new2("NC");
@@ -10843,35 +10831,35 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10843
10831
 
10844
10832
  array = rb_ary_new();
10845
10833
  if( bitmask & SQL_TXN_READ_UNCOMMITTED ) {
10846
- #ifdef UNICODE_SUPPORT_VERSION
10834
+ #ifdef UNICODE_SUPPORT_VERSION_H
10847
10835
  rb_ary_push(array, _ruby_ibm_db_export_char_to_utf8_rstr("UR"));
10848
10836
  #else
10849
10837
  rb_ary_push(array, rb_str_new2("UR"));
10850
10838
  #endif
10851
10839
  }
10852
10840
  if( bitmask & SQL_TXN_READ_COMMITTED ) {
10853
- #ifdef UNICODE_SUPPORT_VERSION
10841
+ #ifdef UNICODE_SUPPORT_VERSION_H
10854
10842
  rb_ary_push(array, _ruby_ibm_db_export_char_to_utf8_rstr("CS"));
10855
10843
  #else
10856
10844
  rb_ary_push(array, rb_str_new2("CS"));
10857
10845
  #endif
10858
10846
  }
10859
10847
  if( bitmask & SQL_TXN_REPEATABLE_READ ) {
10860
- #ifdef UNICODE_SUPPORT_VERSION
10848
+ #ifdef UNICODE_SUPPORT_VERSION_H
10861
10849
  rb_ary_push(array, _ruby_ibm_db_export_char_to_utf8_rstr("RS"));
10862
10850
  #else
10863
10851
  rb_ary_push(array, rb_str_new2("RS"));
10864
10852
  #endif
10865
10853
  }
10866
10854
  if( bitmask & SQL_TXN_SERIALIZABLE ) {
10867
- #ifdef UNICODE_SUPPORT_VERSION
10855
+ #ifdef UNICODE_SUPPORT_VERSION_H
10868
10856
  rb_ary_push(array, _ruby_ibm_db_export_char_to_utf8_rstr("RR"));
10869
10857
  #else
10870
10858
  rb_ary_push(array, rb_str_new2("RR"));
10871
10859
  #endif
10872
10860
  }
10873
10861
  if( bitmask & SQL_TXN_NOCOMMIT ) {
10874
- #ifdef UNICODE_SUPPORT_VERSION
10862
+ #ifdef UNICODE_SUPPORT_VERSION_H
10875
10863
  rb_ary_push(array, _ruby_ibm_db_export_char_to_utf8_rstr("NC"));
10876
10864
  #else
10877
10865
  rb_ary_push(array, rb_str_new2("NC"));
@@ -10897,28 +10885,28 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10897
10885
  VALUE conformance = Qnil;
10898
10886
  switch (bufferint32) {
10899
10887
  case SQL_SC_SQL92_ENTRY:
10900
- #ifdef UNICODE_SUPPORT_VERSION
10888
+ #ifdef UNICODE_SUPPORT_VERSION_H
10901
10889
  conformance = _ruby_ibm_db_export_char_to_utf8_rstr("ENTRY");
10902
10890
  #else
10903
10891
  conformance = rb_str_new2("ENTRY");
10904
10892
  #endif
10905
10893
  break;
10906
10894
  case SQL_SC_FIPS127_2_TRANSITIONAL:
10907
- #ifdef UNICODE_SUPPORT_VERSION
10895
+ #ifdef UNICODE_SUPPORT_VERSION_H
10908
10896
  conformance = _ruby_ibm_db_export_char_to_utf8_rstr("FIPS127");
10909
10897
  #else
10910
10898
  conformance = rb_str_new2("FIPS127");
10911
10899
  #endif
10912
10900
  break;
10913
10901
  case SQL_SC_SQL92_FULL:
10914
- #ifdef UNICODE_SUPPORT_VERSION
10902
+ #ifdef UNICODE_SUPPORT_VERSION_H
10915
10903
  conformance = _ruby_ibm_db_export_char_to_utf8_rstr("FULL");
10916
10904
  #else
10917
10905
  conformance = rb_str_new2("FULL");
10918
10906
  #endif
10919
10907
  break;
10920
10908
  case SQL_SC_SQL92_INTERMEDIATE:
10921
- #ifdef UNICODE_SUPPORT_VERSION
10909
+ #ifdef UNICODE_SUPPORT_VERSION_H
10922
10910
  conformance = _ruby_ibm_db_export_char_to_utf8_rstr("INTERMEDIATE");
10923
10911
  #else
10924
10912
  conformance = rb_str_new2("INTERMEDIATE");
@@ -10943,7 +10931,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10943
10931
  getInfo_args->return_value = Qfalse;
10944
10932
  return Qfalse;
10945
10933
  } else {
10946
- #ifdef UNICODE_SUPPORT_VERSION
10934
+ #ifdef UNICODE_SUPPORT_VERSION_H
10947
10935
  if( rb_str_equal(_ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer11, out_length), _ruby_ibm_db_export_char_to_utf8_rstr("Y")) ) {
10948
10936
  #else
10949
10937
  if( strcmp((char *)buffer11, "Y") == 0 ) {
@@ -10967,7 +10955,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10967
10955
  getInfo_args->return_value = Qfalse;
10968
10956
  return Qfalse;
10969
10957
  } else {
10970
- #ifdef UNICODE_SUPPORT_VERSION
10958
+ #ifdef UNICODE_SUPPORT_VERSION_H
10971
10959
  rb_iv_set(return_value, "@IDENTIFIER_QUOTE_CHAR", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer11, out_length));
10972
10960
  #else
10973
10961
  rb_iv_set(return_value, "@IDENTIFIER_QUOTE_CHAR", rb_str_new2(buffer11));
@@ -10988,7 +10976,7 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
10988
10976
  getInfo_args->return_value = Qfalse;
10989
10977
  return Qfalse;
10990
10978
  } else {
10991
- #ifdef UNICODE_SUPPORT_VERSION
10979
+ #ifdef UNICODE_SUPPORT_VERSION_H
10992
10980
  if( rb_str_equal(_ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer11, out_length), _ruby_ibm_db_export_char_to_utf8_rstr("Y")) ) {
10993
10981
  #else
10994
10982
  if( strcmp(buffer11, "Y") == 0 ) {
@@ -11271,9 +11259,10 @@ VALUE ibm_db_server_info(int argc, VALUE *argv, VALUE self)
11271
11259
  getInfo_args->infoType = 0;
11272
11260
  getInfo_args->infoValue = NULL;
11273
11261
  getInfo_args->buff_length = 0;
11274
- #ifdef UNICODE_SUPPORT_VERSION
11275
- ibm_Ruby_Thread_Call ( (void *)ibm_db_server_info_helper, getInfo_args,
11276
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
11262
+ #ifdef UNICODE_SUPPORT_VERSION_H
11263
+ // Thread.current.report_on_exception = Qfalse;
11264
+ ibm_Ruby_Thread_Call ( (void *)ibm_db_server_info_helper, getInfo_args,
11265
+ RUBY_UBF_IO, NULL);
11277
11266
  return_value = getInfo_args->return_value;
11278
11267
  #else
11279
11268
  return_value = ibm_db_server_info_helper( getInfo_args );
@@ -11298,7 +11287,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11298
11287
  int rc = 0;
11299
11288
  SQLSMALLINT out_length = 0;
11300
11289
 
11301
- #ifndef UNICODE_SUPPORT_VERSION
11290
+ #ifndef UNICODE_SUPPORT_VERSION_H
11302
11291
  char buffer255[255];
11303
11292
  #else
11304
11293
  SQLWCHAR buffer255[255];
@@ -11325,7 +11314,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11325
11314
  getInfo_args->return_value = Qfalse;
11326
11315
  return Qfalse;
11327
11316
  } else {
11328
- #ifdef UNICODE_SUPPORT_VERSION
11317
+ #ifdef UNICODE_SUPPORT_VERSION_H
11329
11318
  rb_iv_set(return_value, "@DRIVER_NAME", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
11330
11319
  #else
11331
11320
  rb_iv_set(return_value, "@DRIVER_NAME", rb_str_new2(buffer255));
@@ -11346,7 +11335,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11346
11335
  getInfo_args->return_value = Qfalse;
11347
11336
  return Qfalse;
11348
11337
  } else {
11349
- #ifdef UNICODE_SUPPORT_VERSION
11338
+ #ifdef UNICODE_SUPPORT_VERSION_H
11350
11339
  rb_iv_set(return_value, "@DRIVER_VER", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
11351
11340
  #else
11352
11341
  rb_iv_set(return_value, "@DRIVER_VER", rb_str_new2(buffer255));
@@ -11367,7 +11356,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11367
11356
  getInfo_args->return_value = Qfalse;
11368
11357
  return Qfalse;
11369
11358
  } else {
11370
- #ifdef UNICODE_SUPPORT_VERSION
11359
+ #ifdef UNICODE_SUPPORT_VERSION_H
11371
11360
  rb_iv_set(return_value, "@DATA_SOURCE_NAME", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
11372
11361
  #else
11373
11362
  rb_iv_set(return_value, "@DATA_SOURCE_NAME", rb_str_new2(buffer255));
@@ -11388,7 +11377,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11388
11377
  getInfo_args->return_value = Qfalse;
11389
11378
  return Qfalse;
11390
11379
  } else {
11391
- #ifdef UNICODE_SUPPORT_VERSION
11380
+ #ifdef UNICODE_SUPPORT_VERSION_H
11392
11381
  rb_iv_set(return_value, "@DRIVER_ODBC_VER", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
11393
11382
  #else
11394
11383
  rb_iv_set(return_value, "@DRIVER_ODBC_VER", rb_str_new2(buffer255));
@@ -11410,7 +11399,7 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11410
11399
  getInfo_args->return_value = Qfalse;
11411
11400
  return Qfalse;
11412
11401
  } else {
11413
- #ifdef UNICODE_SUPPORT_VERSION
11402
+ #ifdef UNICODE_SUPPORT_VERSION_H
11414
11403
  rb_iv_set(return_value, "@ODBC_VER", _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(buffer255, out_length));
11415
11404
  #else
11416
11405
  rb_iv_set(return_value, "@ODBC_VER", rb_str_new2(buffer255));
@@ -11435,21 +11424,21 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
11435
11424
  VALUE conformance = Qnil;
11436
11425
  switch (bufferint16) {
11437
11426
  case SQL_OSC_MINIMUM:
11438
- #ifdef UNICODE_SUPPORT_VERSION
11427
+ #ifdef UNICODE_SUPPORT_VERSION_H
11439
11428
  conformance = _ruby_ibm_db_export_char_to_utf8_rstr("MINIMUM");
11440
11429
  #else
11441
11430
  conformance = rb_str_new2("MINIMUM");
11442
11431
  #endif
11443
11432
  break;
11444
11433
  case SQL_OSC_CORE:
11445
- #ifdef UNICODE_SUPPORT_VERSION
11434
+ #ifdef UNICODE_SUPPORT_VERSION_H
11446
11435
  conformance = _ruby_ibm_db_export_char_to_utf8_rstr("CORE");
11447
11436
  #else
11448
11437
  conformance = rb_str_new2("CORE");
11449
11438
  #endif
11450
11439
  break;
11451
11440
  case SQL_OSC_EXTENDED:
11452
- #ifdef UNICODE_SUPPORT_VERSION
11441
+ #ifdef UNICODE_SUPPORT_VERSION_H
11453
11442
  conformance = _ruby_ibm_db_export_char_to_utf8_rstr("EXTENDED");
11454
11443
  #else
11455
11444
  conformance = rb_str_new2("EXTENDED");
@@ -11567,10 +11556,10 @@ VALUE ibm_db_client_info(int argc, VALUE *argv, VALUE self)
11567
11556
  getInfo_args->infoType = 0;
11568
11557
  getInfo_args->infoValue = NULL;
11569
11558
  getInfo_args->buff_length = 0;
11570
-
11571
- #ifdef UNICODE_SUPPORT_VERSION
11559
+ // using the default unblock funtion RUBY_UBF_IO instead of defined unblock function
11560
+ #ifdef UNICODE_SUPPORT_VERSION_H
11572
11561
  ibm_Ruby_Thread_Call ( (void *)ibm_db_client_info_helper, getInfo_args,
11573
- (void *)_ruby_ibm_db_Connection_level_UBF, NULL);
11562
+ RUBY_UBF_IO, NULL);
11574
11563
  return_value = getInfo_args->return_value;
11575
11564
 
11576
11565
  #else
@@ -11686,7 +11675,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11686
11675
  VALUE r_type = Qnil;
11687
11676
  VALUE ret_val = Qnil;
11688
11677
 
11689
- #ifdef UNICODE_SUPPORT_VERSION
11678
+ #ifdef UNICODE_SUPPORT_VERSION_H
11690
11679
  SQLWCHAR *value = NULL;
11691
11680
  #else
11692
11681
  SQLCHAR *value = NULL;
@@ -11722,7 +11711,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11722
11711
  if (!NIL_P(option)) {
11723
11712
  op_integer=(SQLINTEGER)FIX2INT(option);
11724
11713
  /* ACCTSTR_LEN is the largest possible length of the options to retrieve */
11725
- #ifdef UNICODE_SUPPORT_VERSION
11714
+ #ifdef UNICODE_SUPPORT_VERSION_H
11726
11715
  value = (SQLWCHAR *)ALLOC_N(SQLWCHAR, ACCTSTR_LEN + 1);
11727
11716
  memset(value,'\0', (ACCTSTR_LEN + 1)*sizeof(SQLWCHAR));
11728
11717
  #else
@@ -11735,7 +11724,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11735
11724
  get_handleAttr_args->handle = &( conn_res->hdbc );
11736
11725
  get_handleAttr_args->attribute = op_integer;
11737
11726
  get_handleAttr_args->valuePtr = (SQLPOINTER)value;
11738
- #ifdef UNICODE_SUPPORT_VERSION
11727
+ #ifdef UNICODE_SUPPORT_VERSION_H
11739
11728
  get_handleAttr_args->buff_length = (ACCTSTR_LEN+1)*sizeof(SQLWCHAR);
11740
11729
  #else
11741
11730
  get_handleAttr_args->buff_length = (ACCTSTR_LEN+1);
@@ -11749,7 +11738,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
11749
11738
  _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
11750
11739
  ret_val = Qfalse;
11751
11740
  } else {
11752
- #ifdef UNICODE_SUPPORT_VERSION
11741
+ #ifdef UNICODE_SUPPORT_VERSION_H
11753
11742
  ret_val = _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(value, out_length);
11754
11743
  #else
11755
11744
  ret_val = rb_str_new2((char *)value);
@@ -11885,3 +11874,6 @@ VALUE ibm_db_get_last_serial_value(int argc, VALUE *argv, VALUE self)
11885
11874
  * vim600: noet sw=4 ts=4 fdm=marker
11886
11875
  * vim<600: noet sw=4 ts=4
11887
11876
  */
11877
+
11878
+ /*
11879
+ +----------------------------------------------------------------------+*/