From 65c08e10903e99869aae4f9ee13ce19b726e2cde Mon Sep 17 00:00:00 2001 From: Jacques Distler Date: Mon, 15 Dec 2008 14:45:15 -0600 Subject: [PATCH] Update SQLite3 Drivers Update bundled drivers to version 1.2.4. --- config/environment.rb | 1 - vendor/plugins/sqlite3-ruby/CHANGELOG.rdoc | 49 + vendor/plugins/sqlite3-ruby/LICENSE | 27 + vendor/plugins/sqlite3-ruby/README.rdoc | 51 + vendor/plugins/sqlite3-ruby/Rakefile | 192 + .../sqlite3-ruby/ext/sqlite3_api/MANIFEST | 4 + .../sqlite3-ruby/ext/sqlite3_api/Makefile | 146 + .../sqlite3-ruby/ext/sqlite3_api/extconf.rb | 16 + .../sqlite3-ruby/ext/sqlite3_api/mkmf.log | 71 + .../ext/sqlite3_api/sqlite3_api.i | 358 ++ .../ext/sqlite3_api/sqlite3_api_wrap.c | 3102 +++++++++++++++++ .../ext/sqlite3_api/win32/build.bat | 7 + vendor/plugins/sqlite3-ruby/lib/sqlite3.rb | 1 + .../{ => lib}/sqlite3/constants.rb | 32 - .../{ => lib}/sqlite3/database.rb | 44 +- .../{ => lib}/sqlite3/driver/dl/api.rb | 32 - .../{ => lib}/sqlite3/driver/dl/driver.rb | 33 +- .../{ => lib}/sqlite3/driver/native/driver.rb | 34 +- .../sqlite3-ruby/{ => lib}/sqlite3/errors.rb | 34 +- .../sqlite3-ruby/{ => lib}/sqlite3/pragmas.rb | 40 +- .../{ => lib}/sqlite3/resultset.rb | 78 +- .../{ => lib}/sqlite3/statement.rb | 38 +- .../{ => lib}/sqlite3/translator.rb | 51 +- .../plugins/sqlite3-ruby/lib/sqlite3/value.rb | 57 + .../sqlite3-ruby/lib/sqlite3/version.rb | 14 + vendor/plugins/sqlite3-ruby/setup.rb | 1333 +++++++ vendor/plugins/sqlite3-ruby/sqlite3.rb | 33 - vendor/plugins/sqlite3-ruby/sqlite3/value.rb | 89 - .../plugins/sqlite3-ruby/sqlite3/version.rb | 46 - vendor/plugins/sqlite3-ruby/test/bm.rb | 140 + .../sqlite3-ruby/test/driver/dl/tc_driver.rb | 292 ++ vendor/plugins/sqlite3-ruby/test/mocks.rb | 45 + .../plugins/sqlite3-ruby/test/native-vs-dl.rb | 126 + .../plugins/sqlite3-ruby/test/tc_database.rb | 198 ++ vendor/plugins/sqlite3-ruby/test/tc_errors.rb | 21 + .../sqlite3-ruby/test/tc_integration.rb | 1044 ++++++ vendor/plugins/sqlite3-ruby/test/tests.rb | 6 + 37 files changed, 7364 insertions(+), 521 deletions(-) create mode 100644 vendor/plugins/sqlite3-ruby/CHANGELOG.rdoc create mode 100644 vendor/plugins/sqlite3-ruby/LICENSE create mode 100644 vendor/plugins/sqlite3-ruby/README.rdoc create mode 100644 vendor/plugins/sqlite3-ruby/Rakefile create mode 100644 vendor/plugins/sqlite3-ruby/ext/sqlite3_api/MANIFEST create mode 100644 vendor/plugins/sqlite3-ruby/ext/sqlite3_api/Makefile create mode 100644 vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb create mode 100644 vendor/plugins/sqlite3-ruby/ext/sqlite3_api/mkmf.log create mode 100644 vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i create mode 100644 vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c create mode 100755 vendor/plugins/sqlite3-ruby/ext/sqlite3_api/win32/build.bat create mode 100644 vendor/plugins/sqlite3-ruby/lib/sqlite3.rb rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/constants.rb (50%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/database.rb (92%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/driver/dl/api.rb (77%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/driver/dl/driver.rb (83%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/driver/native/driver.rb (76%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/errors.rb (56%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/pragmas.rb (79%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/resultset.rb (61%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/statement.rb (78%) rename vendor/plugins/sqlite3-ruby/{ => lib}/sqlite3/translator.rb (62%) create mode 100644 vendor/plugins/sqlite3-ruby/lib/sqlite3/value.rb create mode 100644 vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb create mode 100644 vendor/plugins/sqlite3-ruby/setup.rb delete mode 100644 vendor/plugins/sqlite3-ruby/sqlite3.rb delete mode 100644 vendor/plugins/sqlite3-ruby/sqlite3/value.rb delete mode 100644 vendor/plugins/sqlite3-ruby/sqlite3/version.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/bm.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/driver/dl/tc_driver.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/mocks.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/native-vs-dl.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/tc_database.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/tc_errors.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/tc_integration.rb create mode 100644 vendor/plugins/sqlite3-ruby/test/tests.rb diff --git a/config/environment.rb b/config/environment.rb index 8e70485f..05bd8afc 100644 --- a/config/environment.rb +++ b/config/environment.rb @@ -51,7 +51,6 @@ Rails::Initializer.run do |config| # (enables use of different database adapters for development and test environments) config.active_record.schema_format = :sql - config.load_paths << "#{RAILS_ROOT}/vendor/plugins/sqlite3-ruby" File.umask(0026) end diff --git a/vendor/plugins/sqlite3-ruby/CHANGELOG.rdoc b/vendor/plugins/sqlite3-ruby/CHANGELOG.rdoc new file mode 100644 index 00000000..49cf1b21 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/CHANGELOG.rdoc @@ -0,0 +1,49 @@ +=== 1.2.4 / 27 Aug 2008 + +* Package the updated C file for source builds. [Jamis Buck] + + +=== 1.2.3 / 26 Aug 2008 + +* Fix incorrect permissions on database.rb and translator.rb [Various] + +* Avoid using Object#extend for greater speedups [Erik Veenstra] + +* Ruby 1.9 compatibility tweaks for Array#zip [jimmy88@gmail.com] + +* Fix linking against Ruby 1.8.5 [Rob Holland ] + + +=== 1.2.2 / 31 May 2008 + +* Make the table_info method adjust the returned default value for the rows + so that the sqlite3 change in 3.3.8 and greater can be handled + transparently [Jamis Buck ] + +* Ruby 1.9 compatibility tweaks [Roman Le Negrate ] + +* Various performance enhancements [thanks Erik Veenstra] + +* Correct busy_handler documentation [Rob Holland ] + +* Use int_bind64 on Fixnum values larger than a 32bit C int can take. [Rob Holland ] + +* Work around a quirk in SQLite's error reporting by calling sqlite3_reset + to produce a more informative error code upon a failure from + sqlite3_step. [Rob Holland ] + +* Various documentation, test, and style tweaks [Rob Holland ] + +* Be more granular with time/data translation [Rob Holland ] + +* Use Date directly for parsing rather than going via Time [Rob Holland ] + +* Check for the rt library and fdatasync so we link against that when + needed [Rob Holland ] + +* Rename data structures to avoid collision on win32. based on patch + by: Luis Lavena [Rob Holland ] + +* Add test for defaults [Daniel Rodríguez Troitiño] + +* Correctly unquote double-quoted pragma defaults [Łukasz Dargiewicz ] diff --git a/vendor/plugins/sqlite3-ruby/LICENSE b/vendor/plugins/sqlite3-ruby/LICENSE new file mode 100644 index 00000000..75c06824 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/LICENSE @@ -0,0 +1,27 @@ +Copyright (c) 2004, Jamis Buck (jamis@jamisbuck.org) +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + + * The names of its contributors may not be used to endorse or promote + products derived from this software without specific prior written + permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/plugins/sqlite3-ruby/README.rdoc b/vendor/plugins/sqlite3-ruby/README.rdoc new file mode 100644 index 00000000..5b8eecea --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/README.rdoc @@ -0,0 +1,51 @@ += SQLite3/Ruby Interface + +This module allows Ruby programs to interface with the SQLite3 +database engine (http://www.sqlite.org). You must have the +SQLite engine installed in order to build this module. + +Note that this module is NOT compatible with SQLite 2.x. + + +== Compilation and Installation + +Simply do the following, after installing SQLite3: + + ruby setup.rb config + ruby setup.rb setup + ruby setup.rb install + +Alternatively, you can download and install the RubyGem package for +SQLite3/Ruby (you must have RubyGems and SQLite3 installed, first): + + gem install sqlite3-ruby + +If you have sqlite3 installed in a non-standard location, you can specify the location of the include and lib files by doing: + + gem install sqlite3-ruby -- --with-sqlite3-include=/opt/local/include \ + --with-sqlite3-lib=/opt/local/lib + +Also, the gem ships with the C source-code pre-built, so (as of version 1.1.1) +you no longer need to have SWIG installed. However, if you have SWIG installed +and you want to generate the C file yourself, you can specify the +--with-swig option. + +== Usage + +For help figuring out the SQLite3/Ruby interface, check out the +FAQ[http://sqlite-ruby.rubyforge.org/sqlite3/faq.html]. It includes examples of +usage. If you have any questions that you feel should be address in the +FAQ, please send them to jamis@37signals.com + +== Source Code + +The source repository is accessible via git: + + git clone git://github.com/jamis/sqlite3-ruby.git + +== Contact Information + +The project page is http://rubyforge.org/projects/sqlite-ruby. There, you can +find links to mailing lists and forums that you can use to discuss this +library. Additionally, there are trackers for submitting bugs and feature +requests. Feel free to use them! diff --git a/vendor/plugins/sqlite3-ruby/Rakefile b/vendor/plugins/sqlite3-ruby/Rakefile new file mode 100644 index 00000000..bd8a3f31 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/Rakefile @@ -0,0 +1,192 @@ +require 'rubygems' +require 'rake' +require 'rake/testtask' +require 'rake/rdoctask' +require 'rake/contrib/sshpublisher' + +require "./lib/sqlite3/version" + +PACKAGE_NAME = "sqlite3-ruby" +PACKAGE_VERSION = SQLite3::Version::STRING + +puts "name : #{PACKAGE_NAME}" +puts "version: #{PACKAGE_VERSION}" + +SOURCE_FILES = FileList.new do |fl| + [ "ext", "lib", "test" ].each do |dir| + fl.include "#{dir}/**/*" + end + fl.include "Rakefile" +end + +PACKAGE_FILES = FileList.new do |fl| + [ "api", "doc" ].each do |dir| + fl.include "#{dir}/**/*" + end + fl.include "CHANGELOG.rdoc", "README.rdoc", "LICENSE", "#{PACKAGE_NAME}.gemspec", "setup.rb" + fl.include SOURCE_FILES +end + +Gem.manage_gems + +def can_require( file ) + begin + require file + return true + rescue LoadError + return false + end +end + +desc "Default task" +task :default => [ :test ] + +desc "Clean generated files" +task :clean do + rm_rf "ChangeLog" + rm_rf "pkg" + rm_rf "api" + rm_f "doc/faq/faq.html" + + native_files = [ "Makefile", "mkmf.log", "sqlite3_api.so", + "sqlite3_api.bundle", "sqlite3_api_wrap.o" ] + native_files.each { |f| rm_f "ext/sqlite3_api/#{f}" } +end + +desc "Run benchmarks vs. sqlite-ruby" +task :benchmark do + ruby "test/bm.rb" +end + +desc "Run benchmarks dl vs. native" +task :benchmark2 do + ruby "test/native-vs-dl.rb" +end + +desc "Generate the FAQ document" +task :faq => "doc/faq/faq.html" + +file "doc/faq/faq.html" => [ "doc/faq/faq.rb", "doc/faq/faq.yml" ] do + cd( "doc/faq" ) { ruby "faq.rb > faq.html" } +end + +Rake::TestTask.new do |t| + t.test_files = [ "test/tests.rb" ] + t.verbose = true +end + +desc "Build all packages" +task :package + +package_name = "#{PACKAGE_NAME}-#{PACKAGE_VERSION}" +package_dir = "pkg" +package_dir_path = "#{package_dir}/#{package_name}" + +gz_file = "#{package_name}.tar.gz" +bz2_file = "#{package_name}.tar.bz2" +zip_file = "#{package_name}.zip" +gem_file = "#{package_name}.gem" + +task :gzip => SOURCE_FILES + [ :faq, :rdoc, "#{package_dir}/#{gz_file}" ] +task :bzip => SOURCE_FILES + [ :faq, :rdoc, "#{package_dir}/#{bz2_file}" ] +task :zip => SOURCE_FILES + [ :faq, :rdoc, "#{package_dir}/#{zip_file}" ] +task :gem => SOURCE_FILES + [ :faq, "#{package_dir}/#{gem_file}" ] + +task :package => [ :gzip, :bzip, :zip, :gem ] + +directory package_dir + +file package_dir_path do + mkdir_p package_dir_path rescue nil + PACKAGE_FILES.each do |fn| + f = File.join( package_dir_path, fn ) + if File.directory?( fn ) + mkdir_p f unless File.exist?( f ) + else + dir = File.dirname( f ) + mkdir_p dir unless File.exist?( dir ) + rm_f f + safe_ln fn, f + end + end +end + +file "#{package_dir}/#{zip_file}" => package_dir_path do + rm_f "#{package_dir}/#{zip_file}" + chdir package_dir do + sh %{zip -r #{zip_file} #{package_name}} + end +end + +file "#{package_dir}/#{gz_file}" => package_dir_path do + rm_f "#{package_dir}/#{gz_file}" + chdir package_dir do + sh %{tar czvf #{gz_file} #{package_name}} + end +end + +file "#{package_dir}/#{bz2_file}" => package_dir_path do + rm_f "#{package_dir}/#{bz2_file}" + chdir package_dir do + sh %{tar cjvf #{bz2_file} #{package_name}} + end +end + +file "#{package_dir}/#{gem_file}" => package_dir do + spec = eval(File.read(PACKAGE_NAME+".gemspec")) + Gem::Builder.new(spec).build + mv gem_file, "#{package_dir}/#{gem_file}" +end + +Rake::RDocTask.new do |rdoc| + rdoc.rdoc_dir = 'api' + rdoc.title = "SQLite3/Ruby" + rdoc.options += %w(--line-numbers --inline-source --main README.rdoc) + rdoc.rdoc_files.include('lib/**/*.rb') + + if can_require( "rdoc/generators/template/html/jamis" ) + rdoc.template = "jamis" + end +end + +desc "Publish the API documentation" +task :pubrdoc => [ :rdoc ] do + Rake::SshDirPublisher.new( + "minam@rubyforge.org", + "/var/www/gforge-projects/sqlite-ruby/sqlite3/", + "api" ).upload +end + +desc "Publish the FAQ" +task :pubfaq => [ :faq ] do + Rake::SshFilePublisher.new( + "minam@rubyforge.org", + "/var/www/gforge-projects/sqlite-ruby/sqlite3", + "doc/faq", + "faq.html" ).upload +end + +desc "Publish the documentation" +task :pubdoc => [:pubrdoc, :pubfaq] + +desc "Build the Native extension" +task :build do + cd 'ext/sqlite3_api' do + ruby 'extconf.rb' + system 'make' + end +end + +desc "Package a beta release" +task :beta do + require 'yaml' + system 'svn up' + rev = YAML.load(`svn info`)["Revision"] + version = File.read("lib/sqlite3/version.rb") + version.gsub!(/#:beta-tag:/, %(STRING << ".#{rev}")) + File.open("lib/sqlite3/version.rb", "w") { |f| f.write(version) } + + system "rake gem" + + system "svn revert lib/sqlite3/version.rb" +end diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/MANIFEST b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/MANIFEST new file mode 100644 index 00000000..f335e449 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/MANIFEST @@ -0,0 +1,4 @@ +extconf.rb +post-clean.rb +post-distclean.rb +sqlite3_api.i diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/Makefile b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/Makefile new file mode 100644 index 00000000..2071ffd0 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/Makefile @@ -0,0 +1,146 @@ + +SHELL = /bin/sh + +#### Start of system configuration section. #### + +srcdir = . +topdir = /opt/local/lib/ruby/1.8/i686-darwin9.2.2 +hdrdir = $(topdir) +VPATH = $(srcdir):$(topdir):$(hdrdir) +prefix = $(DESTDIR)/opt/local +exec_prefix = $(prefix) +sitedir = $(prefix)/lib/ruby/site_ruby +rubylibdir = $(libdir)/ruby/$(ruby_version) +archdir = $(rubylibdir)/$(arch) +sbindir = $(exec_prefix)/sbin +vendordir = $(prefix)/lib/ruby/vendor_ruby +datadir = $(prefix)/share +includedir = $(prefix)/include +infodir = $(prefix)/info +sysconfdir = $(prefix)/etc +mandir = $(DESTDIR)/opt/local/share/man +libdir = $(exec_prefix)/lib +sharedstatedir = $(prefix)/com +oldincludedir = $(DESTDIR)/usr/include +sitearchdir = $(sitelibdir)/$(sitearch) +vendorarchdir = $(vendorlibdir)/$(vendorarch) +bindir = $(exec_prefix)/bin +localstatedir = $(prefix)/var +vendorlibdir = $(vendordir)/$(ruby_version) +sitelibdir = $(sitedir)/$(ruby_version) +libexecdir = $(exec_prefix)/libexec + +CC = gcc +LIBRUBY = $(LIBRUBY_SO) +LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a +LIBRUBYARG_SHARED = -l$(RUBY_SO_NAME) +LIBRUBYARG_STATIC = -l$(RUBY_SO_NAME)-static + +RUBY_EXTCONF_H = +CFLAGS = -fno-common -O2 -fno-common -pipe -fno-common +INCFLAGS = -I. -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.2.2 -I. +CPPFLAGS = -DHAVE_SQLITE3_H -I/usr/local/include -I/opt/local/include +CXXFLAGS = $(CFLAGS) +DLDFLAGS = -L. -L/opt/local/lib +LDSHARED = cc -dynamic -bundle -undefined suppress -flat_namespace +AR = ar +EXEEXT = + +RUBY_INSTALL_NAME = ruby +RUBY_SO_NAME = ruby +arch = i686-darwin9.2.2 +sitearch = i686-darwin9.2.2 +vendorarch = i686-darwin9.2.2 +ruby_version = 1.8 +ruby = /opt/local/bin/ruby +RUBY = $(ruby) +RM = rm -f +MAKEDIRS = mkdir -p +INSTALL = /usr/bin/install -c +INSTALL_PROG = $(INSTALL) -m 0755 +INSTALL_DATA = $(INSTALL) -m 644 +COPY = cp + +#### End of system configuration section. #### + +preload = + +libpath = . $(libdir) /usr/local/lib +LIBPATH = -L"." -L"$(libdir)" -L"/usr/local/lib" +DEFFILE = + +CLEANFILES = mkmf.log +DISTCLEANFILES = + +extout = +extout_prefix = +target_prefix = +LOCAL_LIBS = +LIBS = $(LIBRUBYARG_SHARED) -lsqlite3 -lpthread -ldl -lobjc +SRCS = sqlite3_api_wrap.c +OBJS = sqlite3_api_wrap.o +TARGET = sqlite3_api +DLLIB = $(TARGET).bundle +EXTSTATIC = +STATIC_LIB = + +RUBYCOMMONDIR = $(sitedir)$(target_prefix) +RUBYLIBDIR = $(sitelibdir)$(target_prefix) +RUBYARCHDIR = $(sitearchdir)$(target_prefix) + +TARGET_SO = $(DLLIB) +CLEANLIBS = $(TARGET).bundle $(TARGET).il? $(TARGET).tds $(TARGET).map +CLEANOBJS = *.o *.a *.s[ol] *.pdb *.exp *.bak + +all: $(DLLIB) +static: $(STATIC_LIB) + +clean: + @-$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) + +distclean: clean + @-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log + @-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES) + +realclean: distclean +install: install-so install-rb + +install-so: $(RUBYARCHDIR) +install-so: $(RUBYARCHDIR)/$(DLLIB) +$(RUBYARCHDIR)/$(DLLIB): $(DLLIB) + $(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR) +install-rb: pre-install-rb install-rb-default +install-rb-default: pre-install-rb-default +pre-install-rb: Makefile +pre-install-rb-default: Makefile +$(RUBYARCHDIR): + $(MAKEDIRS) $@ + +site-install: site-install-so site-install-rb +site-install-so: install-so +site-install-rb: install-rb + +.SUFFIXES: .c .m .cc .cxx .cpp .C .o + +.cc.o: + $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $< + +.cxx.o: + $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $< + +.cpp.o: + $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $< + +.C.o: + $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) -c $< + +.c.o: + $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) -c $< + +$(DLLIB): $(OBJS) + @-$(RM) $@ + $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS) + + + +$(OBJS): ruby.h defines.h diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb new file mode 100644 index 00000000..b6c9bd6f --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/extconf.rb @@ -0,0 +1,16 @@ +require 'mkmf' + +SWIG_WRAP = "sqlite3_api_wrap.c" + +dir_config( "sqlite3", "/usr/local" ) + +have_library( "rt", "fdatasync" ) + +if have_header( "sqlite3.h" ) && have_library( "sqlite3", "sqlite3_open" ) + if !File.exists?( SWIG_WRAP ) || with_config( "swig", false ) + puts "creating #{SWIG_WRAP}" + system "swig -ruby sqlite3_api.i" or raise "could not build wrapper via swig (perhaps swig is not installed?)" + end + + create_makefile( "sqlite3_api" ) +end diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/mkmf.log b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/mkmf.log new file mode 100644 index 00000000..0f89d250 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/mkmf.log @@ -0,0 +1,71 @@ +have_library: checking for fdatasync() in -lrt... -------------------- no + +"gcc -o conftest -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.2.2 -I. -I/usr/local/include -I/opt/local/include -O2 -fno-common -pipe -fno-common conftest.c -L"." -L"/opt/local/lib" -L"/usr/local/lib" -L. -L/opt/local/lib -lruby-static -lrt -lpthread -ldl -lobjc " +conftest.c: In function ‘t’: +conftest.c:3: error: ‘fdatasync’ undeclared (first use in this function) +conftest.c:3: error: (Each undeclared identifier is reported only once +conftest.c:3: error: for each function it appears in.) +checked program was: +/* begin */ +1: /*top*/ +2: int main() { return 0; } +3: int t() { void ((*volatile p)()); p = (void ((*)()))fdatasync; return 0; } +/* end */ + +"gcc -o conftest -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.2.2 -I. -I/usr/local/include -I/opt/local/include -O2 -fno-common -pipe -fno-common conftest.c -L"." -L"/opt/local/lib" -L"/usr/local/lib" -L. -L/opt/local/lib -lruby-static -lrt -lpthread -ldl -lobjc " +ld: library not found for -lrt +collect2: ld returned 1 exit status +checked program was: +/* begin */ +1: /*top*/ +2: int main() { return 0; } +3: int t() { fdatasync(); return 0; } +/* end */ + +"gcc -o conftest -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.2.2 -I. -I/usr/local/include -I/opt/local/include -O2 -fno-common -pipe -fno-common conftest.c -L"." -L"/opt/local/lib" -L"/usr/local/lib" -L. -L/opt/local/lib -lruby-static -lrt -lpthread -ldl -lobjc " +ld: library not found for -lrt +collect2: ld returned 1 exit status +checked program was: +/* begin */ +1: int fdatasync(); +2: /*top*/ +3: int main() { return 0; } +4: int t() { fdatasync(); return 0; } +/* end */ + +-------------------- + +have_header: checking for sqlite3.h... -------------------- yes + +"gcc -E -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.2.2 -I. -I/usr/local/include -I/opt/local/include -O2 -fno-common -pipe -fno-common conftest.c -o conftest.i" +checked program was: +/* begin */ +1: #include +/* end */ + +-------------------- + +have_library: checking for sqlite3_open() in -lsqlite3... -------------------- yes + +"gcc -o conftest -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.2.2 -I. -I/usr/local/include -I/opt/local/include -O2 -fno-common -pipe -fno-common conftest.c -L"." -L"/opt/local/lib" -L"/usr/local/lib" -L. -L/opt/local/lib -lruby-static -lsqlite3 -lpthread -ldl -lobjc " +conftest.c: In function ‘t’: +conftest.c:3: error: ‘sqlite3_open’ undeclared (first use in this function) +conftest.c:3: error: (Each undeclared identifier is reported only once +conftest.c:3: error: for each function it appears in.) +checked program was: +/* begin */ +1: /*top*/ +2: int main() { return 0; } +3: int t() { void ((*volatile p)()); p = (void ((*)()))sqlite3_open; return 0; } +/* end */ + +"gcc -o conftest -I. -I/opt/local/lib/ruby/1.8/i686-darwin9.2.2 -I. -I/usr/local/include -I/opt/local/include -O2 -fno-common -pipe -fno-common conftest.c -L"." -L"/opt/local/lib" -L"/usr/local/lib" -L. -L/opt/local/lib -lruby-static -lsqlite3 -lpthread -ldl -lobjc " +checked program was: +/* begin */ +1: /*top*/ +2: int main() { return 0; } +3: int t() { sqlite3_open(); return 0; } +/* end */ + +-------------------- + diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i new file mode 100644 index 00000000..784ef865 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api.i @@ -0,0 +1,358 @@ +%module "SQLite3::driver::native::API" +%include "typemaps.i" +%{ +#include +#include "ruby.h" + +#ifndef RSTRING_PTR +#define RSTRING_PTR(s) (RSTRING(s)->ptr) +#endif + +#ifndef RSTRING_LEN +#define RSTRING_LEN(s) (RSTRING(s)->len) +#endif + +#define Init_API Init_sqlite3_api + +struct CallbackData { + VALUE proc; + VALUE proc2; + VALUE data; +}; + +typedef struct CallbackData CallbackData; +typedef void RUBY_BLOB; +typedef void RUBY_VALBLOB; + +int Sqlite3_ruby_busy_handler(void* data,int value) { + VALUE result; + CallbackData *cb = (CallbackData*)data; + result = rb_funcall( + cb->proc, rb_intern("call"), 2, cb->data, INT2FIX(value) ); + return FIX2INT(result); +} + +static void mark_CallbackData(void* ptr) { + CallbackData* cb = (CallbackData*)ptr; + if (cb->proc != Qnil) + rb_gc_mark(cb->proc); + if (cb->proc2 != Qnil) + rb_gc_mark(cb->proc2); + if (cb->data != Qnil) + rb_gc_mark(cb->data); +} + +int Sqlite3_ruby_authorizer(void* data,int type, + const char* a,const char* b,const char* c,const char* d) +{ + VALUE result; + CallbackData *cb = (CallbackData*)data; + result = rb_funcall( + cb->proc, rb_intern("call"), 6, cb->data, INT2FIX(type), + ( a ? rb_str_new2(a) : Qnil ), ( b ? rb_str_new2(b) : Qnil ), + ( c ? rb_str_new2(c) : Qnil ), ( d ? rb_str_new2(d) : Qnil ) ); + return FIX2INT(result); +} + +void Sqlite3_ruby_trace(void* data, const char *sql) { + CallbackData *cb = (CallbackData*)data; + rb_funcall( cb->proc, rb_intern("call"), 2, cb->data, + sql ? rb_str_new2(sql) : Qnil ); +} + +void Sqlite3_ruby_function_step(sqlite3_context* ctx,int n, + sqlite3_value** args) +{ + CallbackData *data; + VALUE rb_args; + VALUE *rb_context; + int idx; + + data = (CallbackData*)sqlite3_user_data(ctx); + + if( data->proc2 != Qnil ) { + rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); + if( *rb_context == 0 ) { + *rb_context = rb_hash_new(); + rb_gc_register_address( rb_context ); + } + } + + rb_args = rb_ary_new2(n+1); + rb_ary_push( rb_args, SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); + for( idx = 0; idx < n; idx++ ) { + rb_ary_push( rb_args, SWIG_NewPointerObj(args[idx], + SWIGTYPE_p_sqlite3_value,0) ); + } + + rb_apply( data->proc, rb_intern("call"), rb_args ); +} + +void Sqlite3_ruby_function_final(sqlite3_context *ctx) { + VALUE *rb_context; + CallbackData *data; + + rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); + if( *rb_context == 0 ) { + *rb_context = rb_hash_new(); + rb_gc_register_address( rb_context ); + } + + data = (CallbackData*)sqlite3_user_data(ctx); + + rb_funcall( data->proc2, rb_intern("call"), 1, + SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); + + rb_gc_unregister_address( rb_context ); +} +%} + +%markfunc CallbackData "mark_CallbackData"; + +struct CallbackData { + VALUE proc; + VALUE proc2; + VALUE data; +}; + +%typemap(in) const void *str { + $1 = (void*)RSTRING_PTR($input); +} + +%typemap(in) (const char *filename, sqlite3**) { + $1 = STR2CSTR($input); + $2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); +} + +%typemap(argout) (const char *filename, sqlite3**) { + VALUE ary; + ary = rb_ary_new2(2); + rb_ary_push( ary, $result ); + rb_ary_push( ary, SWIG_NewPointerObj( *$2, SWIGTYPE_p_sqlite3, 0 ) ); + free( $2 ); + $result = ary; +} + +%typemap(in) (const void *filename, sqlite3**) { + $1 = (void*)RSTRING_PTR($input); + $2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); +} + +%typemap(argout) (const void *filename, sqlite3**) { + VALUE ary; + ary = rb_ary_new2(2); + rb_ary_push( ary, $result ); + rb_ary_push( ary, SWIG_NewPointerObj( *$2, SWIGTYPE_p_sqlite3, 0 ) ); + free( $2 ); + $result = ary; +} + +typedef void RUBY_BLOB; +%typemap(out) const RUBY_BLOB * { + $result = $1 ? + rb_str_new( (char*)$1, sqlite3_column_bytes( arg1, arg2 ) ) : Qnil; +} + +typedef void RUBY_VALBLOB; +%typemap(out) const RUBY_VALBLOB * { + $result = $1 ? rb_str_new( (char*)$1, sqlite3_value_bytes( arg1 ) ) : Qnil; +} + +%typemap(out) const void * { + int i; + if( $1 ) { + for( i = 0; ((char*)$1)[i]; i += 2 ); + $result = rb_str_new( (char*)$1, i ); + } else $result = Qnil; +} + +%typemap(in) (const char * sql,int,sqlite3_stmt**,const char**) (sqlite3_stmt *stmt, char *errmsg) { + $1 = RSTRING_PTR($input); + $2 = RSTRING_LEN($input); + $3 = &stmt2; + $4 = &errmsg2; +} + +%typemap(argout) (const char* sql,int,sqlite3_stmt**,const char**) { + VALUE ary; + ary = rb_ary_new2(3); + rb_ary_push( ary, $result ); + rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); + rb_ary_push( ary, errmsg2 ? rb_str_new2( errmsg2 ) : Qnil ); + $result = ary; +} + +%typemap(in) (const void* sql,int,sqlite3_stmt**,const void**) (sqlite3_stmt *stmt, void *errmsg) { + $1 = RSTRING_PTR($input); + $2 = RSTRING_LEN($input); + $3 = &stmt2; + $4 = &errmsg2; +} + +%typemap(argout) (const void* sql,int,sqlite3_stmt**,const void**) { + VALUE ary; + int i; + + for( i = 0; ((char*)errmsg2)[i]; i += 2 ); + + ary = rb_ary_new2(3); + rb_ary_push( ary, $result ); + rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); + rb_ary_push( ary, errmsg2 ? rb_str_new( (char*)errmsg2, i ) : Qnil ); + $result = ary; +} + +%typemap(in) (const void *blob,int) { + $1 = (void*)RSTRING_PTR($input); + $2 = RSTRING_LEN($input); +} + +%typemap(in) (const void *blob,int,void(*free)(void*)) { + $1 = (void*)RSTRING_PTR($input); + $2 = RSTRING_LEN($input); + $3 = SQLITE_TRANSIENT; +} + +%typemap(in) (const char *text,int) { + $1 = RSTRING_PTR($input); + $2 = RSTRING_LEN($input); +} + +%typemap(in) (const char *text,int,void(*free)(void*)) { + $1 = RSTRING_PTR($input); + $2 = RSTRING_LEN($input); + $3 = SQLITE_TRANSIENT; +} + +%typemap(in) (const void *utf16,int) { + $1 = (void*)RSTRING_PTR($input); + $2 = RSTRING_LEN($input); +} + +%typemap(in) (const void *utf16,int,void(*free)(void*)) { + $1 = (void*)RSTRING_PTR($input); + $2 = RSTRING_LEN($input); + $3 = SQLITE_TRANSIENT; +} + +%typemap(out) sqlite_int64 { + $result = rb_ll2inum( $1 ); +} + +%typemap(out) const char * { + $result = $1 ? rb_str_new2($1) : Qnil; +} + +%typemap(in) sqlite_int64 { + $1 = rb_num2ll( $input ); +} + +%typemap(in) (sqlite3_context*,int data_size) { + SWIG_ConvertPtr($input,(void**)&$1, SWIGTYPE_p_sqlite3_context, 1); + $2 = 4; +} + +%typemap(out) VALUE* { + $result = *(VALUE*)$1; +} + +%constant int Sqlite3_ruby_busy_handler(void*,int); +%constant int Sqlite3_ruby_authorizer(void*,int,const char*,const char*,const char*,const char*); +%constant void Sqlite3_ruby_trace(void*,const char*); +%constant void Sqlite3_ruby_function_step(sqlite3_context* ctx,int n, + sqlite3_value** args); +%constant void Sqlite3_ruby_function_final(sqlite3_context* ctx); + +const char *sqlite3_libversion(void); +int sqlite3_close(sqlite3*); + +sqlite_int64 sqlite3_last_insert_rowid(sqlite3*); + +int sqlite3_changes(sqlite3*); +int sqlite3_total_changes(sqlite3*); +void sqlite3_interrupt(sqlite3*); + +int sqlite3_complete(const char*); +int sqlite3_complete16(const void *str); + +int sqlite3_busy_handler(sqlite3*, int(*)(void*,int), void*); +int sqlite3_busy_timeout(sqlite3*,int); +int sqlite3_set_authorizer(sqlite3*, int(*)(void*,int,const char*,const char*,const char*,const char*), void*); +int sqlite3_trace(sqlite3*, void(*)(void*,const char*), void*); + +int sqlite3_open(const char *filename, sqlite3 **); +int sqlite3_open16(const void *filename, sqlite3 **); + +int sqlite3_errcode(sqlite3*); +const char *sqlite3_errmsg(sqlite3*); +const void *sqlite3_errmsg16(sqlite3*); + +int sqlite3_prepare(sqlite3*,const char* sql,int,sqlite3_stmt**,const char**); +int sqlite3_prepare16(sqlite3*,const void* sql,int,sqlite3_stmt**,const void**); + +int sqlite3_bind_blob(sqlite3_stmt*,int,const void *blob,int,void(*free)(void*)); +int sqlite3_bind_double(sqlite3_stmt*,int,double); +int sqlite3_bind_int(sqlite3_stmt*,int,int); +int sqlite3_bind_int64(sqlite3_stmt*,int,sqlite_int64); +int sqlite3_bind_null(sqlite3_stmt*,int); +int sqlite3_bind_text(sqlite3_stmt*,int,const char*text,int,void(*free)(void*)); +int sqlite3_bind_text16(sqlite3_stmt*,int,const void*utf16,int,void(*free)(void*)); + +int sqlite3_bind_parameter_count(sqlite3_stmt*); +const char *sqlite3_bind_parameter_name(sqlite3_stmt*,int); +int sqlite3_bind_parameter_index(sqlite3_stmt*,const char*); + +int sqlite3_column_count(sqlite3_stmt*); +const char *sqlite3_column_name(sqlite3_stmt*,int); +const void *sqlite3_column_name16(sqlite3_stmt*,int); +const char *sqlite3_column_decltype(sqlite3_stmt*,int); +const void *sqlite3_column_decltype16(sqlite3_stmt*,int); + +int sqlite3_step(sqlite3_stmt*); + +int sqlite3_data_count(sqlite3_stmt*); + +const RUBY_BLOB *sqlite3_column_blob(sqlite3_stmt*,int); +int sqlite3_column_bytes(sqlite3_stmt*,int); +int sqlite3_column_bytes16(sqlite3_stmt*,int); +double sqlite3_column_double(sqlite3_stmt*,int); +double sqlite3_column_int(sqlite3_stmt*,int); +sqlite_int64 sqlite3_column_int64(sqlite3_stmt*,int); +const char *sqlite3_column_text(sqlite3_stmt*,int); +const void *sqlite3_column_text16(sqlite3_stmt*,int); +int sqlite3_column_type(sqlite3_stmt*,int); + +int sqlite3_finalize(sqlite3_stmt*); +int sqlite3_reset(sqlite3_stmt*); + +int sqlite3_create_function(sqlite3*,const char*str,int,int,void*,void(*func)(sqlite3_context*,int,sqlite3_value**),void(*step)(sqlite3_context*,int,sqlite3_value**),void(*final)(sqlite3_context*)); + +int sqlite3_create_function16(sqlite3*,const void*str,int,int,void*,void(*func)(sqlite3_context*,int,sqlite3_value**),void(*step)(sqlite3_context*,int,sqlite3_value**),void(*final)(sqlite3_context*)); + +int sqlite3_aggregate_count(sqlite3_context*); + +const RUBY_VALBLOB *sqlite3_value_blob(sqlite3_value*); +int sqlite3_value_bytes(sqlite3_value*); +int sqlite3_value_bytes16(sqlite3_value*); +double sqlite3_value_double(sqlite3_value*); +int sqlite3_value_int(sqlite3_value*); +sqlite_int64 sqlite3_value_int64(sqlite3_value*); +const char *sqlite3_value_text(sqlite3_value*); +const void *sqlite3_value_text16(sqlite3_value*); +const void *sqlite3_value_text16le(sqlite3_value*); +const void *sqlite3_value_text16be(sqlite3_value*); +int sqlite3_value_type(sqlite3_value*); + +void sqlite3_result_blob(sqlite3_context*,const void *blob,int,void(*free)(void*)); +void sqlite3_result_double(sqlite3_context*,double); +void sqlite3_result_error(sqlite3_context*,const char *text,int); +void sqlite3_result_error16(sqlite3_context*,const void *blob,int); +void sqlite3_result_int(sqlite3_context*,int); +void sqlite3_result_int64(sqlite3_context*,sqlite_int64); +void sqlite3_result_text(sqlite3_context*,const char* text,int,void(*free)(void*)); +void sqlite3_result_text16(sqlite3_context*,const void* utf16,int,void(*free)(void*)); +void sqlite3_result_text16le(sqlite3_context*,const void* utf16,int,void(*free)(void*)); +void sqlite3_result_text16be(sqlite3_context*,const void* utf16,int,void(*free)(void*)); +void sqlite3_result_value(sqlite3_context*,sqlite3_value*); + +VALUE *sqlite3_aggregate_context(sqlite3_context*,int data_size); diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c new file mode 100644 index 00000000..90126790 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/sqlite3_api_wrap.c @@ -0,0 +1,3102 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.27 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +/*********************************************************************** + * + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * + ************************************************************************/ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) || defined(__ICC) +# define SWIGUNUSED __attribute__ ((unused)) +# else +# define SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods for Windows DLLs */ +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# define SWIGEXPORT +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + + +/* ruby.swg */ +/* Implementation : RUBY */ +#define SWIGRUBY 1 + +#include "ruby.h" + +/* Flags for pointer conversion */ +#define SWIG_POINTER_EXCEPTION 0x1 +#define SWIG_POINTER_OWN 0x1 +#define SWIG_POINTER_DISOWN 0x2 +#define SWIG_TRACK_OBJECTS 0x4 + +#define NUM2USHRT(n) (\ + (0 <= NUM2UINT(n) && NUM2UINT(n) <= USHRT_MAX)\ + ? (unsigned short) NUM2UINT(n) \ + : (rb_raise(rb_eArgError, "integer %d out of range of `unsigned short'",\ + NUM2UINT(n)), (short)0)\ +) + +#define NUM2SHRT(n) (\ + (SHRT_MIN <= NUM2INT(n) && NUM2INT(n) <= SHRT_MAX)\ + ? (short)NUM2INT(n)\ + : (rb_raise(rb_eArgError, "integer %d out of range of `short'",\ + NUM2INT(n)), (short)0)\ +) + +/* Ruby 1.7 defines NUM2LL(), LL2NUM() and ULL2NUM() macros */ +#ifndef NUM2LL +#define NUM2LL(x) NUM2LONG((x)) +#endif +#ifndef LL2NUM +#define LL2NUM(x) INT2NUM((long) (x)) +#endif +#ifndef ULL2NUM +#define ULL2NUM(x) UINT2NUM((unsigned long) (x)) +#endif + +/* Ruby 1.7 doesn't (yet) define NUM2ULL() */ +#ifndef NUM2ULL +#ifdef HAVE_LONG_LONG +#define NUM2ULL(x) rb_num2ull((x)) +#else +#define NUM2ULL(x) NUM2ULONG(x) +#endif +#endif + +/* + * Need to be very careful about how these macros are defined, especially + * when compiling C++ code or C code with an ANSI C compiler. + * + * VALUEFUNC(f) is a macro used to typecast a C function that implements + * a Ruby method so that it can be passed as an argument to API functions + * like rb_define_method() and rb_define_singleton_method(). + * + * VOIDFUNC(f) is a macro used to typecast a C function that implements + * either the "mark" or "free" stuff for a Ruby Data object, so that it + * can be passed as an argument to API functions like Data_Wrap_Struct() + * and Data_Make_Struct(). + */ + +#ifdef __cplusplus +# ifndef RUBY_METHOD_FUNC /* These definitions should work for Ruby 1.4.6 */ +# define PROTECTFUNC(f) ((VALUE (*)()) f) +# define VALUEFUNC(f) ((VALUE (*)()) f) +# define VOIDFUNC(f) ((void (*)()) f) +# else +# ifndef ANYARGS /* These definitions should work for Ruby 1.6 */ +# define PROTECTFUNC(f) ((VALUE (*)()) f) +# define VALUEFUNC(f) ((VALUE (*)()) f) +# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) +# else /* These definitions should work for Ruby 1.7+ */ +# define PROTECTFUNC(f) ((VALUE (*)(VALUE)) f) +# define VALUEFUNC(f) ((VALUE (*)(ANYARGS)) f) +# define VOIDFUNC(f) ((RUBY_DATA_FUNC) f) +# endif +# endif +#else +# define VALUEFUNC(f) (f) +# define VOIDFUNC(f) (f) +#endif + +typedef struct { + VALUE klass; + VALUE mImpl; + void (*mark)(void *); + void (*destroy)(void *); +} swig_class; + +/* Don't use for expressions have side effect */ +#ifndef RB_STRING_VALUE +#define RB_STRING_VALUE(s) (TYPE(s) == T_STRING ? (s) : (*(volatile VALUE *)&(s) = rb_str_to_str(s))) +#endif +#ifndef StringValue +#define StringValue(s) RB_STRING_VALUE(s) +#endif +#ifndef StringValuePtr +#define StringValuePtr(s) RSTRING(RB_STRING_VALUE(s))->ptr +#endif +#ifndef StringValueLen +#define StringValueLen(s) RSTRING(RB_STRING_VALUE(s))->len +#endif +#ifndef SafeStringValue +#define SafeStringValue(v) do {\ + StringValue(v);\ + rb_check_safe_str(v);\ +} while (0) +#endif + +#ifndef HAVE_RB_DEFINE_ALLOC_FUNC +#define rb_define_alloc_func(klass, func) rb_define_singleton_method((klass), "new", VALUEFUNC((func)), -1) +#define rb_undef_alloc_func(klass) rb_undef_method(CLASS_OF((klass)), "new") +#endif + +/* Contract support */ + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { rb_raise(rb_eRuntimeError, (char *) msg ); } else + + +/*********************************************************************** + * swigrun.swg + * + * This file contains generic CAPI SWIG runtime support for pointer + * type checking. + * + ************************************************************************/ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "2" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the swig runtime code. + In 99.9% of the cases, swig just needs to declare them as 'static'. + + But only do this if is strictly necessary, ie, if you have problems + with your compiler or so. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store inforomation on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (int)(*f1 - *f2); + } + return (l1 - f1) - (l2 - f2); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCompare(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + + +/* think of this as a c++ template<> or a scheme macro */ +#define SWIG_TypeCheck_Template(comparison, ty) \ + if (ty) { \ + swig_cast_info *iter = ty->cast; \ + while (iter) { \ + if (comparison) { \ + if (iter == ty->cast) return iter; \ + /* Move iter to the top of the linked list */ \ + iter->prev->next = iter->next; \ + if (iter->next) \ + iter->next->prev = iter->prev; \ + iter->next = ty->cast; \ + iter->prev = 0; \ + if (ty->cast) ty->cast->prev = iter; \ + ty->cast = iter; \ + return iter; \ + } \ + iter = iter->next; \ + } \ + } \ + return 0 + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); +} + +/* Same as previous function, except strcmp is replaced with a pointer comparison */ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { + SWIG_TypeCheck_Template(iter->type == from, into); +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + register size_t l = 0; + register size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + register size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + register int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + register size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + register const unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + register unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register char d = *(c++); + register unsigned char uu = 0; + if ((d >= '0') && (d <= '9')) + uu = ((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = ((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/*********************************************************************** + * rubytracking.swg + * + * This file contains support for tracking mappings from + * Ruby objects to C++ objects. This functionality is needed + * to implement mark functions for Ruby's mark and sweep + * garbage collector. + ************************************************************************/ + +/* Global Ruby hash table to store Trackings from C/C++ + structs to Ruby Objects. */ +static VALUE swig_ruby_trackings; + +/* Setup a Ruby hash table to store Trackings */ +static void SWIG_RubyInitializeTrackings() { + /* Create a ruby hash table to store Trackings from C++ + objects to Ruby objects. Also make sure to tell + the garabage collector about the hash table. */ + swig_ruby_trackings = rb_hash_new(); + rb_gc_register_address(&swig_ruby_trackings); +} + +/* Get a Ruby number to reference a pointer */ +static VALUE SWIG_RubyPtrToReference(void* ptr) { + /* We cast the pointer to an unsigned long + and then store a reference to it using + a Ruby number object. */ + + /* Convert the pointer to a Ruby number */ + unsigned long value = (unsigned long) ptr; + return LONG2NUM(value); +} + +/* Get a Ruby number to reference an object */ +static VALUE SWIG_RubyObjectToReference(VALUE object) { + /* We cast the object to an unsigned long + and then store a reference to it using + a Ruby number object. */ + + /* Convert the Object to a Ruby number */ + unsigned long value = (unsigned long) object; + return LONG2NUM(value); +} + +/* Get a Ruby object from a previously stored reference */ +static VALUE SWIG_RubyReferenceToObject(VALUE reference) { + /* The provided Ruby number object is a reference + to the Ruby object we want.*/ + + /* First convert the Ruby number to a C number */ + unsigned long value = NUM2LONG(reference); + return (VALUE) value; +} + +/* Add a Tracking from a C/C++ struct to a Ruby object */ +static void SWIG_RubyAddTracking(void* ptr, VALUE object) { + /* In a Ruby hash table we store the pointer and + the associated Ruby object. The trick here is + that we cannot store the Ruby object directly - if + we do then it cannot be garbage collected. So + instead we typecast it as a unsigned long and + convert it to a Ruby number object.*/ + + /* Get a reference to the pointer as a Ruby number */ + VALUE key = SWIG_RubyPtrToReference(ptr); + + /* Get a reference to the Ruby object as a Ruby number */ + VALUE value = SWIG_RubyObjectToReference(object); + + /* Store the mapping to the global hash table. */ + rb_hash_aset(swig_ruby_trackings, key, value); +} + +/* Get the Ruby object that owns the specified C/C++ struct */ +static VALUE SWIG_RubyInstanceFor(void* ptr) { + /* Get a reference to the pointer as a Ruby number */ + VALUE key = SWIG_RubyPtrToReference(ptr); + + /* Now lookup the value stored in the global hash table */ + VALUE value = rb_hash_aref(swig_ruby_trackings, key); + + if (value == Qnil) { + /* No object exists - return nil. */ + return Qnil; + } + else { + /* Convert this value to Ruby object */ + return SWIG_RubyReferenceToObject(value); + } +} + +/* Remove a Tracking from a C/C++ struct to a Ruby object */ +static void SWIG_RubyRemoveTracking(void* ptr) { + /* Get a reference to the pointer as a Ruby number */ + VALUE key = SWIG_RubyPtrToReference(ptr); + + /* Define delete method - in C++ this could be marked as + static but unfortunately not in C. */ + VALUE delete_function = rb_intern("delete"); + + /* Delete the object from the hash table by calling Ruby's + do this we need to call the Hash.delete method.*/ + rb_funcall(swig_ruby_trackings, delete_function, 1, key); +} + +/* This is a helper method that unlinks a Ruby object from its + underlying C++ object. This is needed if the lifetime of the + Ruby object is longer than the C++ object */ +static void SWIG_RubyUnlinkObjects(void* ptr) { + VALUE object = SWIG_RubyInstanceFor(ptr); + + if (object != Qnil) { + DATA_PTR(object) = 0; + } +} + +/* Common SWIG API */ +#define SWIG_ConvertPtr(obj, pp, type, flags) \ + SWIG_Ruby_ConvertPtr(obj, pp, type, flags) +#define SWIG_NewPointerObj(p, type, flags) \ + SWIG_Ruby_NewPointerObj(p, type, flags) +#define SWIG_MustGetPtr(p, type, argnum, flags) \ + SWIG_Ruby_MustGetPtr(p, type, argnum, flags) +#define SWIG_GetModule(clientdata) \ + SWIG_Ruby_GetModule() +#define SWIG_SetModule(clientdata, pointer) \ + SWIG_Ruby_SetModule(pointer) + +/* Ruby-specific SWIG API */ + +#define SWIG_InitRuntime() \ + SWIG_Ruby_InitRuntime() +#define SWIG_define_class(ty) \ + SWIG_Ruby_define_class(ty) +#define SWIG_NewClassInstance(value, ty) \ + SWIG_Ruby_NewClassInstance(value, ty) +#define SWIG_MangleStr(value) \ + SWIG_Ruby_MangleStr(value) +#define SWIG_CheckConvert(value, ty) \ + SWIG_Ruby_CheckConvert(value, ty) +#define SWIG_NewPackedObj(ptr, sz, ty) \ + SWIG_Ruby_NewPackedObj(ptr, sz, ty) +#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) \ + SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags) + +/* rubydef.swg */ +#ifdef __cplusplus +extern "C" { +#endif + +static VALUE _mSWIG = Qnil; +static VALUE _cSWIG_Pointer = Qnil; +static VALUE swig_runtime_data_type_pointer = Qnil; + +/* Initialize Ruby runtime support */ +static void +SWIG_Ruby_InitRuntime(void) +{ + if (_mSWIG == Qnil) { + _mSWIG = rb_define_module("SWIG"); + } +} + +/* Define Ruby class for C type */ +static void +SWIG_Ruby_define_class(swig_type_info *type) +{ + VALUE klass; + char *klass_name = (char *) malloc(4 + strlen(type->name) + 1); + sprintf(klass_name, "TYPE%s", type->name); + if (NIL_P(_cSWIG_Pointer)) { + _cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject); + rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new"); + } + klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer); + free((void *) klass_name); +} + +/* Create a new pointer object */ +static VALUE +SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags) +{ + int own = flags & SWIG_POINTER_OWN; + int track = flags & SWIG_TRACK_OBJECTS; + + char *klass_name; + swig_class *sklass; + VALUE klass; + VALUE obj; + + if (!ptr) + return Qnil; + + /* Have we already wrapped this pointer? */ + if (track) { + obj = SWIG_RubyInstanceFor(ptr); + if (obj != Qnil) { + return obj; + } + } + + if (type->clientdata) { + sklass = (swig_class *) type->clientdata; + obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark), (own ? VOIDFUNC(sklass->destroy) : 0), ptr); + } else { + klass_name = (char *) malloc(4 + strlen(type->name) + 1); + sprintf(klass_name, "TYPE%s", type->name); + klass = rb_const_get(_mSWIG, rb_intern(klass_name)); + free((void *) klass_name); + obj = Data_Wrap_Struct(klass, 0, 0, ptr); + } + rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name)); + + /* Keep track of this object if necessary */ + if (track) { + SWIG_RubyAddTracking(ptr, obj); + } + + return obj; +} + +/* Create a new class instance (always owned) */ +static VALUE +SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type) +{ + VALUE obj; + swig_class *sklass = (swig_class *) type->clientdata; + obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0); + rb_iv_set(obj, "__swigtype__", rb_str_new2(type->name)); + return obj; +} + +/* Get type mangle from class name */ +static SWIGINLINE char * +SWIG_Ruby_MangleStr(VALUE obj) +{ + VALUE stype = rb_iv_get(obj, "__swigtype__"); + return StringValuePtr(stype); +} + +/* Convert a pointer value */ +static int +SWIG_Ruby_ConvertPtr(VALUE obj, void **ptr, swig_type_info *ty, int flags) +{ + char *c; + swig_cast_info *tc; + + /* Grab the pointer */ + if (NIL_P(obj)) { + *ptr = 0; + return 0; + } else { + Data_Get_Struct(obj, void, *ptr); + } + + /* Check to see if the input object is giving up ownership + of the underlying C struct or C++ object. If so then we + need to reset the destructor since the Ruby object no + longer owns the underlying C++ object.*/ + if (flags & SWIG_POINTER_DISOWN) { + if (flags & SWIG_TRACK_OBJECTS) { + /* We are tracking objects. Thus we change the destructor + * to SWIG_RubyRemoveTracking. This allows us to + * remove the mapping from the C++ to Ruby object + * when the Ruby object is garbage collected. If we don't + * do this, then it is possible we will return a reference + * to a Ruby object that no longer exists thereby crashing Ruby. */ + RDATA(obj)->dfree = SWIG_RubyRemoveTracking; + } else { + RDATA(obj)->dfree = 0; + } + } + + /* Do type-checking if type info was provided */ + if (ty) { + if (ty->clientdata) { + if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) { + if (*ptr == 0) + rb_raise(rb_eRuntimeError, "This %s already released", ty->str); + return 0; + } + } + if ((c = SWIG_MangleStr(obj)) == NULL) { + if (flags & SWIG_POINTER_EXCEPTION) + rb_raise(rb_eTypeError, "Expected %s", ty->str); + else + return -1; + } + tc = SWIG_TypeCheck(c, ty); + if (!tc) { + if (flags & SWIG_POINTER_EXCEPTION) + rb_raise(rb_eTypeError, "Expected %s", ty->str); + else + return -1; + } + *ptr = SWIG_TypeCast(tc, *ptr); + } + return 0; +} + +/* Convert a pointer value, signal an exception on a type mismatch */ +static SWIGINLINE void * +SWIG_Ruby_MustGetPtr(VALUE obj, swig_type_info *ty, int argnum, int flags) +{ + void *result; + SWIG_ConvertPtr(obj, &result, ty, flags | SWIG_POINTER_EXCEPTION); + return result; +} + +/* Check convert */ +static SWIGINLINE int +SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty) +{ + char *c = SWIG_MangleStr(obj); + if (!c) + return 0; + return SWIG_TypeCheck(c,ty) != 0; +} + +static VALUE +SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) { + char result[1024]; + char *r = result; + if ((2*sz + 1 + strlen(type->name)) > 1000) return 0; + *(r++) = '_'; + r = SWIG_PackData(r, ptr, sz); + strcpy(r, type->name); + return rb_str_new2(result); +} + +/* Convert a packed value value */ +static void +SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags) { + swig_cast_info *tc; + const char *c; + + if (TYPE(obj) != T_STRING) goto type_error; + c = StringValuePtr(obj); + /* Pointer values must start with leading underscore */ + if (*c != '_') goto type_error; + c++; + c = SWIG_UnpackData(c, ptr, sz); + if (ty) { + tc = SWIG_TypeCheck(c, ty); + if (!tc) goto type_error; + } + return; + +type_error: + + if (flags) { + if (ty) { + rb_raise(rb_eTypeError, "Type error. Expected %s", ty->name); + } else { + rb_raise(rb_eTypeError, "Expected a pointer"); + } + } +} + +static swig_module_info *SWIG_Ruby_GetModule() { + VALUE pointer; + swig_module_info *ret = 0; + + /* first check if pointer already created */ + pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + if (pointer != Qnil) { + Data_Get_Struct(pointer, swig_module_info, ret); + } + return ret; +} + +static void SWIG_Ruby_SetModule(swig_module_info *pointer) { + /* register a new class */ + VALUE cl = rb_define_class("swig_runtime_data", rb_cObject); + /* create and store the structure pointer to a global variable */ + swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer); + rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer); +} + +#ifdef __cplusplus +} +#endif + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_CallbackData swig_types[0] +#define SWIGTYPE_p_f_p_sqlite3_context__void swig_types[1] +#define SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void swig_types[2] +#define SWIGTYPE_p_f_p_void__void swig_types[3] +#define SWIGTYPE_p_f_p_void_int__int swig_types[4] +#define SWIGTYPE_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int swig_types[5] +#define SWIGTYPE_p_f_p_void_p_q_const__char__void swig_types[6] +#define SWIGTYPE_p_p_char swig_types[7] +#define SWIGTYPE_p_p_sqlite3 swig_types[8] +#define SWIGTYPE_p_p_sqlite3_stmt swig_types[9] +#define SWIGTYPE_p_p_void swig_types[10] +#define SWIGTYPE_p_sqlite3 swig_types[11] +#define SWIGTYPE_p_sqlite3_context swig_types[12] +#define SWIGTYPE_p_sqlite3_stmt swig_types[13] +#define SWIGTYPE_p_sqlite3_value swig_types[14] +#define SWIGTYPE_p_sqlite_int64 swig_types[15] +#define SWIGTYPE_p_unsigned_long swig_types[16] +#define SWIGTYPE_p_void swig_types[17] +static swig_type_info *swig_types[19]; +static swig_module_info swig_module = {swig_types, 18, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#define SWIG_init Init_API +#define SWIG_name "SQLite3::Driver::Native::API" + +static VALUE mAPI; + +static void SWIG_AsVal(VALUE obj, int *val) +{ + *val = (int) NUM2INT(obj); +} + + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef HAVE_SYS_TIME_H +# include +struct timeval rb_time_timeval(VALUE); +#endif +#ifdef __cplusplus +} +#endif + + +#ifdef __cplusplus +extern "C" { +#endif +#include "rubyio.h" +#ifdef __cplusplus +} +#endif + + +#include +#include "ruby.h" + +#ifndef RSTRING_PTR +#define RSTRING_PTR(s) (RSTRING(s)->ptr) +#endif + +#ifndef RSTRING_LEN +#define RSTRING_LEN(s) (RSTRING(s)->len) +#endif + +#define Init_API Init_sqlite3_api + +struct CallbackData { + VALUE proc; + VALUE proc2; + VALUE data; +}; + +typedef struct CallbackData CallbackData; +typedef void RUBY_BLOB; +typedef void RUBY_VALBLOB; + +int Sqlite3_ruby_busy_handler(void* data,int value) { + VALUE result; + CallbackData *cb = (CallbackData*)data; + result = rb_funcall( + cb->proc, rb_intern("call"), 2, cb->data, INT2FIX(value) ); + return FIX2INT(result); +} + +static void mark_CallbackData(void* ptr) { + CallbackData* cb = (CallbackData*)ptr; + if (cb->proc != Qnil) + rb_gc_mark(cb->proc); + if (cb->proc2 != Qnil) + rb_gc_mark(cb->proc2); + if (cb->data != Qnil) + rb_gc_mark(cb->data); +} + +int Sqlite3_ruby_authorizer(void* data,int type, + const char* a,const char* b,const char* c,const char* d) +{ + VALUE result; + CallbackData *cb = (CallbackData*)data; + result = rb_funcall( + cb->proc, rb_intern("call"), 6, cb->data, INT2FIX(type), + ( a ? rb_str_new2(a) : Qnil ), ( b ? rb_str_new2(b) : Qnil ), + ( c ? rb_str_new2(c) : Qnil ), ( d ? rb_str_new2(d) : Qnil ) ); + return FIX2INT(result); +} + +void Sqlite3_ruby_trace(void* data, const char *sql) { + CallbackData *cb = (CallbackData*)data; + rb_funcall( cb->proc, rb_intern("call"), 2, cb->data, + sql ? rb_str_new2(sql) : Qnil ); +} + +void Sqlite3_ruby_function_step(sqlite3_context* ctx,int n, + sqlite3_value** args) +{ + CallbackData *data; + VALUE rb_args; + VALUE *rb_context; + int idx; + + data = (CallbackData*)sqlite3_user_data(ctx); + + if( data->proc2 != Qnil ) { + rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); + if( *rb_context == 0 ) { + *rb_context = rb_hash_new(); + rb_gc_register_address( rb_context ); + } + } + + rb_args = rb_ary_new2(n+1); + rb_ary_push( rb_args, SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); + for( idx = 0; idx < n; idx++ ) { + rb_ary_push( rb_args, SWIG_NewPointerObj(args[idx], + SWIGTYPE_p_sqlite3_value,0) ); + } + + rb_apply( data->proc, rb_intern("call"), rb_args ); +} + +void Sqlite3_ruby_function_final(sqlite3_context *ctx) { + VALUE *rb_context; + CallbackData *data; + + rb_context = (VALUE*)sqlite3_aggregate_context(ctx,sizeof(VALUE)); + if( *rb_context == 0 ) { + *rb_context = rb_hash_new(); + rb_gc_register_address( rb_context ); + } + + data = (CallbackData*)sqlite3_user_data(ctx); + + rb_funcall( data->proc2, rb_intern("call"), 1, + SWIG_NewPointerObj(ctx,SWIGTYPE_p_sqlite3_context,0) ); + + rb_gc_unregister_address( rb_context ); +} + +swig_class cCallbackData; + +static VALUE +_wrap_CallbackData_proc_set(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE arg2 ; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); + arg2 = argv[0]; + if (arg1) (arg1)->proc = arg2; + + return Qnil; +} + + +static VALUE +_wrap_CallbackData_proc_get(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE result; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); + SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); + result = (VALUE) ((arg1)->proc); + + vresult = result; + return vresult; +} + + +static VALUE +_wrap_CallbackData_proc2_set(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE arg2 ; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); + arg2 = argv[0]; + if (arg1) (arg1)->proc2 = arg2; + + return Qnil; +} + + +static VALUE +_wrap_CallbackData_proc2_get(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE result; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); + SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); + result = (VALUE) ((arg1)->proc2); + + vresult = result; + return vresult; +} + + +static VALUE +_wrap_CallbackData_data_set(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE arg2 ; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); + arg2 = argv[0]; + if (arg1) (arg1)->data = arg2; + + return Qnil; +} + + +static VALUE +_wrap_CallbackData_data_get(int argc, VALUE *argv, VALUE self) { + struct CallbackData *arg1 = (struct CallbackData *) 0 ; + VALUE result; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); + SWIG_ConvertPtr(self, (void **) &arg1, SWIGTYPE_p_CallbackData, 0); + result = (VALUE) ((arg1)->data); + + vresult = result; + return vresult; +} + + +#ifdef HAVE_RB_DEFINE_ALLOC_FUNC +static VALUE +_wrap_CallbackData_allocate(VALUE self) { +#else + static VALUE + _wrap_CallbackData_allocate(int argc, VALUE *argv, VALUE self) { +#endif + + + VALUE vresult = SWIG_NewClassInstance(self, SWIGTYPE_p_CallbackData); +#ifndef HAVE_RB_DEFINE_ALLOC_FUNC + rb_obj_call_init(vresult, argc, argv); +#endif + return vresult; + } + + +static VALUE +_wrap_new_CallbackData(int argc, VALUE *argv, VALUE self) { + struct CallbackData *result; + + if ((argc < 0) || (argc > 0)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); + result = (struct CallbackData *)(struct CallbackData *) calloc(1, sizeof(struct CallbackData)); + DATA_PTR(self) = result; + + return self; +} + + +static void +free_CallbackData(struct CallbackData *arg1) { + free((char *) arg1); +} + +static VALUE +_wrap_sqlite3_libversion(int argc, VALUE *argv, VALUE self) { + char *result; + VALUE vresult = Qnil; + + if ((argc < 0) || (argc > 0)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); + result = (char *)sqlite3_libversion(); + + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_close(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + result = (int)sqlite3_close(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_last_insert_rowid(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + sqlite_int64 result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + result = sqlite3_last_insert_rowid(arg1); + + { + vresult = rb_ll2inum( result ); + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_changes(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + result = (int)sqlite3_changes(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_total_changes(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + result = (int)sqlite3_total_changes(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_interrupt(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + sqlite3_interrupt(arg1); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_complete(int argc, VALUE *argv, VALUE self) { + char *arg1 = (char *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + arg1 = StringValuePtr(argv[0]); + result = (int)sqlite3_complete((char const *)arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_complete16(int argc, VALUE *argv, VALUE self) { + void *arg1 = (void *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + { + arg1 = (void*)RSTRING_PTR(argv[0]); + } + result = (int)sqlite3_complete16((void const *)arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_busy_handler(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int (*arg2)(void *,int) = (int (*)(void *,int)) 0 ; + void *arg3 = (void *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_f_p_void_int__int, 0); + SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, SWIG_POINTER_EXCEPTION|0); + result = (int)sqlite3_busy_handler(arg1,arg2,arg3); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_busy_timeout(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int arg2 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + arg2 = NUM2INT(argv[1]); + result = (int)sqlite3_busy_timeout(arg1,arg2); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_set_authorizer(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int (*arg2)(void *,int,char const *,char const *,char const *,char const *) = (int (*)(void *,int,char const *,char const *,char const *,char const *)) 0 ; + void *arg3 = (void *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int, 0); + SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, SWIG_POINTER_EXCEPTION|0); + result = (int)sqlite3_set_authorizer(arg1,arg2,arg3); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_trace(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void (*arg2)(void *,char const *) = (void (*)(void *,char const *)) 0 ; + void *arg3 = (void *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_f_p_void_p_q_const__char__void, 0); + SWIG_ConvertPtr(argv[2], (void **) &arg3, 0, SWIG_POINTER_EXCEPTION|0); + result = (int)sqlite3_trace(arg1,arg2,arg3); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_open(int argc, VALUE *argv, VALUE self) { + char *arg1 = (char *) 0 ; + sqlite3 **arg2 = (sqlite3 **) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + { + arg1 = STR2CSTR(argv[0]); + arg2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); + } + result = (int)sqlite3_open((char const *)arg1,arg2); + + vresult = INT2NUM(result); + { + VALUE ary; + ary = rb_ary_new2(2); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( *arg2, SWIGTYPE_p_sqlite3, 0 ) ); + free( arg2 ); + vresult = ary; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_open16(int argc, VALUE *argv, VALUE self) { + void *arg1 = (void *) 0 ; + sqlite3 **arg2 = (sqlite3 **) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + { + arg1 = (void*)RSTRING_PTR(argv[0]); + arg2 = (sqlite3**)malloc( sizeof( sqlite3* ) ); + } + result = (int)sqlite3_open16((void const *)arg1,arg2); + + vresult = INT2NUM(result); + { + VALUE ary; + ary = rb_ary_new2(2); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( *arg2, SWIGTYPE_p_sqlite3, 0 ) ); + free( arg2 ); + vresult = ary; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_errcode(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + result = (int)sqlite3_errcode(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_errmsg(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + char *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + result = (char *)sqlite3_errmsg(arg1); + + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_errmsg16(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + result = (void *)sqlite3_errmsg16(arg1); + + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_prepare(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ; + char **arg5 = (char **) 0 ; + int result; + sqlite3_stmt *stmt2 ; + char *errmsg2 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = &stmt2; + arg5 = &errmsg2; + } + result = (int)sqlite3_prepare(arg1,(char const *)arg2,arg3,arg4,(char const **)arg5); + + vresult = INT2NUM(result); + { + VALUE ary; + ary = rb_ary_new2(3); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); + rb_ary_push( ary, errmsg2 ? rb_str_new2( errmsg2 ) : Qnil ); + vresult = ary; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_prepare16(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + sqlite3_stmt **arg4 = (sqlite3_stmt **) 0 ; + void **arg5 = (void **) 0 ; + int result; + sqlite3_stmt *stmt2 ; + void *errmsg2 ; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = &stmt2; + arg5 = &errmsg2; + } + result = (int)sqlite3_prepare16(arg1,(void const *)arg2,arg3,arg4,(void const **)arg5); + + vresult = INT2NUM(result); + { + VALUE ary; + int i; + + for( i = 0; ((char*)errmsg2)[i]; i += 2 ); + + ary = rb_ary_new2(3); + rb_ary_push( ary, vresult ); + rb_ary_push( ary, SWIG_NewPointerObj( stmt2, SWIGTYPE_p_sqlite3_stmt, 0 ) ); + rb_ary_push( ary, errmsg2 ? rb_str_new( (char*)errmsg2, i ) : Qnil ); + vresult = ary; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *arg3 = (void *) 0 ; + int arg4 ; + void (*arg5)(void *) = (void (*)(void *)) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + { + arg3 = (void*)RSTRING_PTR(argv[2]); + arg4 = RSTRING_LEN(argv[2]); + arg5 = SQLITE_TRANSIENT; + } + result = (int)sqlite3_bind_blob(arg1,arg2,(void const *)arg3,arg4,arg5); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_double(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + double arg3 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + arg3 = (double) NUM2DBL(argv[2]); + result = (int)sqlite3_bind_double(arg1,arg2,arg3); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_int(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + int arg3 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + arg3 = NUM2INT(argv[2]); + result = (int)sqlite3_bind_int(arg1,arg2,arg3); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + sqlite_int64 arg3 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + { + arg3 = rb_num2ll( argv[2] ); + } + result = (int)sqlite3_bind_int64(arg1,arg2,arg3); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_null(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (int)sqlite3_bind_null(arg1,arg2); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_text(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + char *arg3 = (char *) 0 ; + int arg4 ; + void (*arg5)(void *) = (void (*)(void *)) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + { + arg3 = RSTRING_PTR(argv[2]); + arg4 = RSTRING_LEN(argv[2]); + arg5 = SQLITE_TRANSIENT; + } + result = (int)sqlite3_bind_text(arg1,arg2,(char const *)arg3,arg4,arg5); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *arg3 = (void *) 0 ; + int arg4 ; + void (*arg5)(void *) = (void (*)(void *)) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 3) || (argc > 3)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + { + arg3 = (void*)RSTRING_PTR(argv[2]); + arg4 = RSTRING_LEN(argv[2]); + arg5 = SQLITE_TRANSIENT; + } + result = (int)sqlite3_bind_text16(arg1,arg2,(void const *)arg3,arg4,arg5); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_parameter_count(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + result = (int)sqlite3_bind_parameter_count(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_parameter_name(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + char *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (char *)sqlite3_bind_parameter_name(arg1,arg2); + + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_bind_parameter_index(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + char *arg2 = (char *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = StringValuePtr(argv[1]); + result = (int)sqlite3_bind_parameter_index(arg1,(char const *)arg2); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_count(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + result = (int)sqlite3_column_count(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_name(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + char *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (char *)sqlite3_column_name(arg1,arg2); + + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_name16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (void *)sqlite3_column_name16(arg1,arg2); + + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_decltype(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + char *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (char *)sqlite3_column_decltype(arg1,arg2); + + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_decltype16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (void *)sqlite3_column_decltype16(arg1,arg2); + + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_step(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + result = (int)sqlite3_step(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_data_count(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + result = (int)sqlite3_data_count(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + RUBY_BLOB *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (RUBY_BLOB *)sqlite3_column_blob(arg1,arg2); + + { + vresult = result ? + rb_str_new( (char*)result, sqlite3_column_bytes( arg1, arg2 ) ) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_bytes(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (int)sqlite3_column_bytes(arg1,arg2); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_bytes16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (int)sqlite3_column_bytes16(arg1,arg2); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_double(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + double result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (double)sqlite3_column_double(arg1,arg2); + + vresult = rb_float_new(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_int(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + double result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (double)sqlite3_column_int(arg1,arg2); + + vresult = rb_float_new(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + sqlite_int64 result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = sqlite3_column_int64(arg1,arg2); + + { + vresult = rb_ll2inum( result ); + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_text(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + char *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (char *)sqlite3_column_text(arg1,arg2); + + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + void *result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (void *)sqlite3_column_text16(arg1,arg2); + + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_column_type(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int arg2 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + arg2 = NUM2INT(argv[1]); + result = (int)sqlite3_column_type(arg1,arg2); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_finalize(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + result = (int)sqlite3_finalize(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_reset(int argc, VALUE *argv, VALUE self) { + sqlite3_stmt *arg1 = (sqlite3_stmt *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_stmt, 0); + result = (int)sqlite3_reset(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_create_function(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int arg4 ; + void *arg5 = (void *) 0 ; + void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 8) || (argc > 8)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + arg2 = StringValuePtr(argv[1]); + arg3 = NUM2INT(argv[2]); + arg4 = NUM2INT(argv[3]); + SWIG_ConvertPtr(argv[4], (void **) &arg5, 0, SWIG_POINTER_EXCEPTION|0); + SWIG_ConvertPtr(argv[5], (void **) &arg6, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); + SWIG_ConvertPtr(argv[6], (void **) &arg7, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); + SWIG_ConvertPtr(argv[7], (void **) &arg8, SWIGTYPE_p_f_p_sqlite3_context__void, 0); + result = (int)sqlite3_create_function(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_create_function16(int argc, VALUE *argv, VALUE self) { + sqlite3 *arg1 = (sqlite3 *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + int arg4 ; + void *arg5 = (void *) 0 ; + void (*arg6)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg7)(sqlite3_context *,int,sqlite3_value **) = (void (*)(sqlite3_context *,int,sqlite3_value **)) 0 ; + void (*arg8)(sqlite3_context *) = (void (*)(sqlite3_context *)) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 8) || (argc > 8)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3, 0); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + } + arg3 = NUM2INT(argv[2]); + arg4 = NUM2INT(argv[3]); + SWIG_ConvertPtr(argv[4], (void **) &arg5, 0, SWIG_POINTER_EXCEPTION|0); + SWIG_ConvertPtr(argv[5], (void **) &arg6, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); + SWIG_ConvertPtr(argv[6], (void **) &arg7, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0); + SWIG_ConvertPtr(argv[7], (void **) &arg8, SWIGTYPE_p_f_p_sqlite3_context__void, 0); + result = (int)sqlite3_create_function16(arg1,(void const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_aggregate_count(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + result = (int)sqlite3_aggregate_count(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + RUBY_VALBLOB *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (RUBY_VALBLOB *)sqlite3_value_blob(arg1); + + { + vresult = result ? rb_str_new( (char*)result, sqlite3_value_bytes( arg1 ) ) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_bytes(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (int)sqlite3_value_bytes(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_bytes16(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (int)sqlite3_value_bytes16(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_double(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + double result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (double)sqlite3_value_double(arg1); + + vresult = rb_float_new(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_int(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (int)sqlite3_value_int(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + sqlite_int64 result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = sqlite3_value_int64(arg1); + + { + vresult = rb_ll2inum( result ); + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_text(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + char *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (char *)sqlite3_value_text(arg1); + + { + vresult = result ? rb_str_new2(result) : Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (void *)sqlite3_value_text16(arg1); + + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_text16le(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (void *)sqlite3_value_text16le(arg1); + + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_text16be(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + void *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (void *)sqlite3_value_text16be(arg1); + + { + int i; + if( result ) { + for( i = 0; ((char*)result)[i]; i += 2 ); + vresult = rb_str_new( (char*)result, i ); + } else vresult = Qnil; + } + return vresult; +} + + +static VALUE +_wrap_sqlite3_value_type(int argc, VALUE *argv, VALUE self) { + sqlite3_value *arg1 = (sqlite3_value *) 0 ; + int result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_value, 0); + result = (int)sqlite3_value_type(arg1); + + vresult = INT2NUM(result); + return vresult; +} + + +static VALUE +_wrap_sqlite3_result_blob(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_blob(arg1,(void const *)arg2,arg3,arg4); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_double(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + double arg2 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + arg2 = (double) NUM2DBL(argv[1]); + sqlite3_result_double(arg1,arg2); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_error(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + } + sqlite3_result_error(arg1,(char const *)arg2,arg3); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_error16(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + } + sqlite3_result_error16(arg1,(void const *)arg2,arg3); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_int(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + int arg2 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + arg2 = NUM2INT(argv[1]); + sqlite3_result_int(arg1,arg2); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_int64(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + sqlite_int64 arg2 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = rb_num2ll( argv[1] ); + } + sqlite3_result_int64(arg1,arg2); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_text(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text(arg1,(char const *)arg2,arg3,arg4); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_text16(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text16(arg1,(void const *)arg2,arg3,arg4); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_text16le(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text16le(arg1,(void const *)arg2,arg3,arg4); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_text16be(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + void *arg2 = (void *) 0 ; + int arg3 ; + void (*arg4)(void *) = (void (*)(void *)) 0 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + { + arg2 = (void*)RSTRING_PTR(argv[1]); + arg3 = RSTRING_LEN(argv[1]); + arg4 = SQLITE_TRANSIENT; + } + sqlite3_result_text16be(arg1,(void const *)arg2,arg3,arg4); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_result_value(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + sqlite3_value *arg2 = (sqlite3_value *) 0 ; + + if ((argc < 2) || (argc > 2)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); + SWIG_ConvertPtr(argv[0], (void **) &arg1, SWIGTYPE_p_sqlite3_context, 0); + SWIG_ConvertPtr(argv[1], (void **) &arg2, SWIGTYPE_p_sqlite3_value, 0); + sqlite3_result_value(arg1,arg2); + + return Qnil; +} + + +static VALUE +_wrap_sqlite3_aggregate_context(int argc, VALUE *argv, VALUE self) { + sqlite3_context *arg1 = (sqlite3_context *) 0 ; + int arg2 ; + VALUE *result; + VALUE vresult = Qnil; + + if ((argc < 1) || (argc > 1)) + rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); + { + SWIG_ConvertPtr(argv[0],(void**)&arg1, SWIGTYPE_p_sqlite3_context, 1); + arg2 = 4; + } + result = (VALUE *)sqlite3_aggregate_context(arg1,arg2); + + { + vresult = *(VALUE*)result; + } + return vresult; +} + + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_CallbackData = {"_p_CallbackData", "struct CallbackData *", 0, 0, 0}; +static swig_type_info _swigt__p_f_p_sqlite3_context__void = {"_p_f_p_sqlite3_context__void", "void (*)(sqlite3_context *)", 0, 0, 0}; +static swig_type_info _swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void = {"_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void", "void (*)(sqlite3_context *,int,sqlite3_value **)", 0, 0, 0}; +static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "void (*)(void *)", 0, 0, 0}; +static swig_type_info _swigt__p_f_p_void_int__int = {"_p_f_p_void_int__int", "int (*)(void *,int)", 0, 0, 0}; +static swig_type_info _swigt__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int = {"_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int", "int (*)(void *,int,char const *,char const *,char const *,char const *)", 0, 0, 0}; +static swig_type_info _swigt__p_f_p_void_p_q_const__char__void = {"_p_f_p_void_p_q_const__char__void", "void (*)(void *,char const *)", 0, 0, 0}; +static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, 0}; +static swig_type_info _swigt__p_p_sqlite3 = {"_p_p_sqlite3", "sqlite3 **", 0, 0, 0}; +static swig_type_info _swigt__p_p_sqlite3_stmt = {"_p_p_sqlite3_stmt", "sqlite3_stmt **", 0, 0, 0}; +static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, 0}; +static swig_type_info _swigt__p_sqlite3 = {"_p_sqlite3", "sqlite3 *", 0, 0, 0}; +static swig_type_info _swigt__p_sqlite3_context = {"_p_sqlite3_context", "sqlite3_context *", 0, 0, 0}; +static swig_type_info _swigt__p_sqlite3_stmt = {"_p_sqlite3_stmt", "sqlite3_stmt *", 0, 0, 0}; +static swig_type_info _swigt__p_sqlite3_value = {"_p_sqlite3_value", "sqlite3_value *", 0, 0, 0}; +static swig_type_info _swigt__p_sqlite_int64 = {"_p_sqlite_int64", "sqlite_int64 *", 0, 0, 0}; +static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|VALUE *", 0, 0, 0}; +static swig_type_info _swigt__p_void = {"_p_void", "void *|RUBY_VALBLOB *", 0, 0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_CallbackData, + &_swigt__p_f_p_sqlite3_context__void, + &_swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, + &_swigt__p_f_p_void__void, + &_swigt__p_f_p_void_int__int, + &_swigt__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int, + &_swigt__p_f_p_void_p_q_const__char__void, + &_swigt__p_p_char, + &_swigt__p_p_sqlite3, + &_swigt__p_p_sqlite3_stmt, + &_swigt__p_p_void, + &_swigt__p_sqlite3, + &_swigt__p_sqlite3_context, + &_swigt__p_sqlite3_stmt, + &_swigt__p_sqlite3_value, + &_swigt__p_sqlite_int64, + &_swigt__p_unsigned_long, + &_swigt__p_void, +}; + +static swig_cast_info _swigc__p_CallbackData[] = { {&_swigt__p_CallbackData, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_sqlite3_context__void[] = { {&_swigt__p_f_p_sqlite3_context__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void[] = { {&_swigt__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_void_int__int[] = { {&_swigt__p_f_p_void_int__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int[] = { {&_swigt__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_f_p_void_p_q_const__char__void[] = { {&_swigt__p_f_p_void_p_q_const__char__void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_sqlite3[] = { {&_swigt__p_p_sqlite3, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_sqlite3_stmt[] = { {&_swigt__p_p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3[] = { {&_swigt__p_sqlite3, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3_context[] = { {&_swigt__p_sqlite3_context, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3_stmt[] = { {&_swigt__p_sqlite3_stmt, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite3_value[] = { {&_swigt__p_sqlite3_value, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_sqlite_int64[] = { {&_swigt__p_sqlite_int64, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_CallbackData, + _swigc__p_f_p_sqlite3_context__void, + _swigc__p_f_p_sqlite3_context_int_p_p_sqlite3_value__void, + _swigc__p_f_p_void__void, + _swigc__p_f_p_void_int__int, + _swigc__p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int, + _swigc__p_f_p_void_p_q_const__char__void, + _swigc__p_p_char, + _swigc__p_p_sqlite3, + _swigc__p_p_sqlite3_stmt, + _swigc__p_p_void, + _swigc__p_sqlite3, + _swigc__p_sqlite3_context, + _swigc__p_sqlite3_stmt, + _swigc__p_sqlite3_value, + _swigc__p_sqlite_int64, + _swigc__p_unsigned_long, + _swigc__p_void, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +/************************************************************************* + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + + * The generated swig_type_info structures are assigned staticly to an initial + * array. We just loop though that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. +**/ + +#ifdef __cplusplus +extern "C" { +#endif + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + swig_type_info *type, *ret; + swig_cast_info *cast; + size_t i; + swig_module_info *module_head; + static int init_run = 0; + + clientdata = clientdata; + + if (init_run) return; + init_run = 1; + + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (module_head) { + swig_module.next = module_head->next; + module_head->next = &swig_module; + } else { + /* This is the first module loaded */ + swig_module.next = &swig_module; + SWIG_SetModule(clientdata, &swig_module); + } + + /* Now work on filling in swig_module.types */ + for (i = 0; i < swig_module.size; ++i) { + type = 0; + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ + if (swig_module.type_initial[i]->clientdata) type->clientdata = swig_module.type_initial[i]->clientdata; + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + + /* Don't need to add information already in the list */ + ret = 0; + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); + } + if (ret && type == swig_module.type_initial[i]) { + cast->type = ret; + ret = 0; + } + + if (!ret) { + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + + cast++; + } + + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +} +#endif + + +#ifdef __cplusplus +extern "C" +#endif +SWIGEXPORT void Init_API(void) { + size_t i; + + SWIG_InitRuntime(); + mAPI = rb_define_module("SQLite3"); + mAPI = rb_define_module_under(mAPI, "Driver"); + mAPI = rb_define_module_under(mAPI, "Native"); + mAPI = rb_define_module_under(mAPI, "API"); + + SWIG_InitializeModule(0); + for (i = 0; i < swig_module.size; i++) { + SWIG_define_class(swig_module.types[i]); + } + + SWIG_RubyInitializeTrackings(); + + cCallbackData.klass = rb_define_class_under(mAPI, "CallbackData", rb_cObject); + SWIG_TypeClientData(SWIGTYPE_p_CallbackData, (void *) &cCallbackData); + rb_define_alloc_func(cCallbackData.klass, _wrap_CallbackData_allocate); + rb_define_method(cCallbackData.klass, "initialize", _wrap_new_CallbackData, -1); + rb_define_method(cCallbackData.klass, "proc=", _wrap_CallbackData_proc_set, -1); + rb_define_method(cCallbackData.klass, "proc", _wrap_CallbackData_proc_get, -1); + rb_define_method(cCallbackData.klass, "proc2=", _wrap_CallbackData_proc2_set, -1); + rb_define_method(cCallbackData.klass, "proc2", _wrap_CallbackData_proc2_get, -1); + rb_define_method(cCallbackData.klass, "data=", _wrap_CallbackData_data_set, -1); + rb_define_method(cCallbackData.klass, "data", _wrap_CallbackData_data_get, -1); + cCallbackData.mark = (void (*)(void *)) mark_CallbackData; + cCallbackData.destroy = (void (*)(void *)) free_CallbackData; + rb_define_const(mAPI,"Sqlite3_ruby_busy_handler", SWIG_NewPointerObj((void *) Sqlite3_ruby_busy_handler, SWIGTYPE_p_f_p_void_int__int,0)); + rb_define_const(mAPI,"Sqlite3_ruby_authorizer", SWIG_NewPointerObj((void *) Sqlite3_ruby_authorizer, SWIGTYPE_p_f_p_void_int_p_q_const__char_p_q_const__char_p_q_const__char_p_q_const__char__int,0)); + rb_define_const(mAPI,"Sqlite3_ruby_trace", SWIG_NewPointerObj((void *) Sqlite3_ruby_trace, SWIGTYPE_p_f_p_void_p_q_const__char__void,0)); + rb_define_const(mAPI,"Sqlite3_ruby_function_step", SWIG_NewPointerObj((void *) Sqlite3_ruby_function_step, SWIGTYPE_p_f_p_sqlite3_context_int_p_p_sqlite3_value__void,0)); + rb_define_const(mAPI,"Sqlite3_ruby_function_final", SWIG_NewPointerObj((void *) Sqlite3_ruby_function_final, SWIGTYPE_p_f_p_sqlite3_context__void,0)); + rb_define_module_function(mAPI, "sqlite3_libversion", _wrap_sqlite3_libversion, -1); + rb_define_module_function(mAPI, "sqlite3_close", _wrap_sqlite3_close, -1); + rb_define_module_function(mAPI, "sqlite3_last_insert_rowid", _wrap_sqlite3_last_insert_rowid, -1); + rb_define_module_function(mAPI, "sqlite3_changes", _wrap_sqlite3_changes, -1); + rb_define_module_function(mAPI, "sqlite3_total_changes", _wrap_sqlite3_total_changes, -1); + rb_define_module_function(mAPI, "sqlite3_interrupt", _wrap_sqlite3_interrupt, -1); + rb_define_module_function(mAPI, "sqlite3_complete", _wrap_sqlite3_complete, -1); + rb_define_module_function(mAPI, "sqlite3_complete16", _wrap_sqlite3_complete16, -1); + rb_define_module_function(mAPI, "sqlite3_busy_handler", _wrap_sqlite3_busy_handler, -1); + rb_define_module_function(mAPI, "sqlite3_busy_timeout", _wrap_sqlite3_busy_timeout, -1); + rb_define_module_function(mAPI, "sqlite3_set_authorizer", _wrap_sqlite3_set_authorizer, -1); + rb_define_module_function(mAPI, "sqlite3_trace", _wrap_sqlite3_trace, -1); + rb_define_module_function(mAPI, "sqlite3_open", _wrap_sqlite3_open, -1); + rb_define_module_function(mAPI, "sqlite3_open16", _wrap_sqlite3_open16, -1); + rb_define_module_function(mAPI, "sqlite3_errcode", _wrap_sqlite3_errcode, -1); + rb_define_module_function(mAPI, "sqlite3_errmsg", _wrap_sqlite3_errmsg, -1); + rb_define_module_function(mAPI, "sqlite3_errmsg16", _wrap_sqlite3_errmsg16, -1); + rb_define_module_function(mAPI, "sqlite3_prepare", _wrap_sqlite3_prepare, -1); + rb_define_module_function(mAPI, "sqlite3_prepare16", _wrap_sqlite3_prepare16, -1); + rb_define_module_function(mAPI, "sqlite3_bind_blob", _wrap_sqlite3_bind_blob, -1); + rb_define_module_function(mAPI, "sqlite3_bind_double", _wrap_sqlite3_bind_double, -1); + rb_define_module_function(mAPI, "sqlite3_bind_int", _wrap_sqlite3_bind_int, -1); + rb_define_module_function(mAPI, "sqlite3_bind_int64", _wrap_sqlite3_bind_int64, -1); + rb_define_module_function(mAPI, "sqlite3_bind_null", _wrap_sqlite3_bind_null, -1); + rb_define_module_function(mAPI, "sqlite3_bind_text", _wrap_sqlite3_bind_text, -1); + rb_define_module_function(mAPI, "sqlite3_bind_text16", _wrap_sqlite3_bind_text16, -1); + rb_define_module_function(mAPI, "sqlite3_bind_parameter_count", _wrap_sqlite3_bind_parameter_count, -1); + rb_define_module_function(mAPI, "sqlite3_bind_parameter_name", _wrap_sqlite3_bind_parameter_name, -1); + rb_define_module_function(mAPI, "sqlite3_bind_parameter_index", _wrap_sqlite3_bind_parameter_index, -1); + rb_define_module_function(mAPI, "sqlite3_column_count", _wrap_sqlite3_column_count, -1); + rb_define_module_function(mAPI, "sqlite3_column_name", _wrap_sqlite3_column_name, -1); + rb_define_module_function(mAPI, "sqlite3_column_name16", _wrap_sqlite3_column_name16, -1); + rb_define_module_function(mAPI, "sqlite3_column_decltype", _wrap_sqlite3_column_decltype, -1); + rb_define_module_function(mAPI, "sqlite3_column_decltype16", _wrap_sqlite3_column_decltype16, -1); + rb_define_module_function(mAPI, "sqlite3_step", _wrap_sqlite3_step, -1); + rb_define_module_function(mAPI, "sqlite3_data_count", _wrap_sqlite3_data_count, -1); + rb_define_module_function(mAPI, "sqlite3_column_blob", _wrap_sqlite3_column_blob, -1); + rb_define_module_function(mAPI, "sqlite3_column_bytes", _wrap_sqlite3_column_bytes, -1); + rb_define_module_function(mAPI, "sqlite3_column_bytes16", _wrap_sqlite3_column_bytes16, -1); + rb_define_module_function(mAPI, "sqlite3_column_double", _wrap_sqlite3_column_double, -1); + rb_define_module_function(mAPI, "sqlite3_column_int", _wrap_sqlite3_column_int, -1); + rb_define_module_function(mAPI, "sqlite3_column_int64", _wrap_sqlite3_column_int64, -1); + rb_define_module_function(mAPI, "sqlite3_column_text", _wrap_sqlite3_column_text, -1); + rb_define_module_function(mAPI, "sqlite3_column_text16", _wrap_sqlite3_column_text16, -1); + rb_define_module_function(mAPI, "sqlite3_column_type", _wrap_sqlite3_column_type, -1); + rb_define_module_function(mAPI, "sqlite3_finalize", _wrap_sqlite3_finalize, -1); + rb_define_module_function(mAPI, "sqlite3_reset", _wrap_sqlite3_reset, -1); + rb_define_module_function(mAPI, "sqlite3_create_function", _wrap_sqlite3_create_function, -1); + rb_define_module_function(mAPI, "sqlite3_create_function16", _wrap_sqlite3_create_function16, -1); + rb_define_module_function(mAPI, "sqlite3_aggregate_count", _wrap_sqlite3_aggregate_count, -1); + rb_define_module_function(mAPI, "sqlite3_value_blob", _wrap_sqlite3_value_blob, -1); + rb_define_module_function(mAPI, "sqlite3_value_bytes", _wrap_sqlite3_value_bytes, -1); + rb_define_module_function(mAPI, "sqlite3_value_bytes16", _wrap_sqlite3_value_bytes16, -1); + rb_define_module_function(mAPI, "sqlite3_value_double", _wrap_sqlite3_value_double, -1); + rb_define_module_function(mAPI, "sqlite3_value_int", _wrap_sqlite3_value_int, -1); + rb_define_module_function(mAPI, "sqlite3_value_int64", _wrap_sqlite3_value_int64, -1); + rb_define_module_function(mAPI, "sqlite3_value_text", _wrap_sqlite3_value_text, -1); + rb_define_module_function(mAPI, "sqlite3_value_text16", _wrap_sqlite3_value_text16, -1); + rb_define_module_function(mAPI, "sqlite3_value_text16le", _wrap_sqlite3_value_text16le, -1); + rb_define_module_function(mAPI, "sqlite3_value_text16be", _wrap_sqlite3_value_text16be, -1); + rb_define_module_function(mAPI, "sqlite3_value_type", _wrap_sqlite3_value_type, -1); + rb_define_module_function(mAPI, "sqlite3_result_blob", _wrap_sqlite3_result_blob, -1); + rb_define_module_function(mAPI, "sqlite3_result_double", _wrap_sqlite3_result_double, -1); + rb_define_module_function(mAPI, "sqlite3_result_error", _wrap_sqlite3_result_error, -1); + rb_define_module_function(mAPI, "sqlite3_result_error16", _wrap_sqlite3_result_error16, -1); + rb_define_module_function(mAPI, "sqlite3_result_int", _wrap_sqlite3_result_int, -1); + rb_define_module_function(mAPI, "sqlite3_result_int64", _wrap_sqlite3_result_int64, -1); + rb_define_module_function(mAPI, "sqlite3_result_text", _wrap_sqlite3_result_text, -1); + rb_define_module_function(mAPI, "sqlite3_result_text16", _wrap_sqlite3_result_text16, -1); + rb_define_module_function(mAPI, "sqlite3_result_text16le", _wrap_sqlite3_result_text16le, -1); + rb_define_module_function(mAPI, "sqlite3_result_text16be", _wrap_sqlite3_result_text16be, -1); + rb_define_module_function(mAPI, "sqlite3_result_value", _wrap_sqlite3_result_value, -1); + rb_define_module_function(mAPI, "sqlite3_aggregate_context", _wrap_sqlite3_aggregate_context, -1); +} + diff --git a/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/win32/build.bat b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/win32/build.bat new file mode 100755 index 00000000..550e720f --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/ext/sqlite3_api/win32/build.bat @@ -0,0 +1,7 @@ +REM This is not guaranteed to work, ever. It's just a little helper +REM script that I threw together to help me build the win32 version of +REM the library. If someone with more win32-fu than I wants to make +REM something more robust, please feel free! I'd love to include it. +REM -- Jamis Buck + +cl /LD /Ie:\WinSDK\Include /Ic:\ruby\lib\ruby\1.8\i386-mswin32 /Ic:\ruby\sqlite3 /Ic:\ruby\src\ruby-1.8.4_2006-04-14 sqlite3_api_wrap.c /link /LIBPATH:c:\ruby\sqlite3 /LIBPATH:e:\WinSDK\Lib /LIBPATH:c:\ruby\lib sqlite3.lib msvcrt-ruby18.lib diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3.rb new file mode 100644 index 00000000..d2d0ea10 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3.rb @@ -0,0 +1 @@ +require 'sqlite3/database' diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/constants.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/constants.rb similarity index 50% rename from vendor/plugins/sqlite3-ruby/sqlite3/constants.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/constants.rb index 5a20e461..b316c2d8 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/constants.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/constants.rb @@ -1,35 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - module SQLite3 ; module Constants module TextRep diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/database.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb similarity index 92% rename from vendor/plugins/sqlite3-ruby/sqlite3/database.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb index 6a130f90..627166c0 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/database.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/database.rb @@ -1,36 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - -require 'base64' require 'sqlite3/constants' require 'sqlite3/errors' require 'sqlite3/pragmas' @@ -180,6 +147,9 @@ module SQLite3 # Returns a Statement object representing the given SQL. This does not # execute the statement; it merely prepares the statement for execution. + # + # The Statement can then be executed using Statement#execute. + # def prepare( sql ) stmt = @statement_factory.new( self, sql ) if block_given? @@ -335,19 +305,19 @@ module SQLite3 # The handler will be invoked with the name of the resource that was # busy, and the number of times it has been retried. # - # See also #busy_timeout. + # See also the mutually exclusive #busy_timeout. def busy_handler( data=nil, &block ) # :yields: data, retries result = @driver.busy_handler( @handle, data, &block ) Error.check( result, self ) end # Indicates that if a request for a resource terminates because that - # resource is busy, SQLite should wait for the indicated number of - # milliseconds before trying again. By default, SQLite does not retry + # resource is busy, SQLite should sleep and retry for up to the indicated + # number of milliseconds. By default, SQLite does not retry # busy resources. To restore the default behavior, send 0 as the # +ms+ parameter. # - # See also #busy_handler. + # See also the mutually exclusive #busy_handler. def busy_timeout( ms ) result = @driver.busy_timeout( @handle, ms ) Error.check( result, self ) diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/driver/dl/api.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/api.rb similarity index 77% rename from vendor/plugins/sqlite3-ruby/sqlite3/driver/dl/api.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/api.rb index 9cea866f..15a8007c 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/driver/dl/api.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/api.rb @@ -1,35 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'dl/import' module SQLite3 ; module Driver; module DL; diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/driver/dl/driver.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/driver.rb similarity index 83% rename from vendor/plugins/sqlite3-ruby/sqlite3/driver/dl/driver.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/driver.rb index ac72e0db..f53c1897 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/driver/dl/driver.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/dl/driver.rb @@ -1,35 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'sqlite3/driver/dl/api' warn "The DL driver for sqlite3-ruby is deprecated and will be removed" @@ -263,6 +231,7 @@ module SQLite3 ; module Driver ; module DL api_delegate :aggregate_count api_delegate :bind_double api_delegate :bind_int + api_delegate :bind_int64 api_delegate :bind_null api_delegate :bind_parameter_index api_delegate :bind_parameter_name diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/driver/native/driver.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/native/driver.rb similarity index 76% rename from vendor/plugins/sqlite3-ruby/sqlite3/driver/native/driver.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/native/driver.rb index cef0cdce..e9784082 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/driver/native/driver.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/driver/native/driver.rb @@ -1,35 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'sqlite3_api' module SQLite3 ; module Driver ; module Native @@ -191,7 +159,7 @@ module SQLite3 ; module Driver ; module Native end def self.api_delegate( name ) - define_method( name ) { |*args| API.send( "sqlite3_#{name}", *args ) } + eval "def #{name} (*args) API.sqlite3_#{name}( *args ) ; end" end api_delegate :libversion diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/errors.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/errors.rb similarity index 56% rename from vendor/plugins/sqlite3-ruby/sqlite3/errors.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/errors.rb index f83adc57..b2014453 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/errors.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/errors.rb @@ -1,40 +1,8 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'sqlite3/constants' module SQLite3 - class Exception < ::Exception + class Exception < ::StandardError @code = 0 # The numeric error code that this exception represents. diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/pragmas.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/pragmas.rb similarity index 79% rename from vendor/plugins/sqlite3-ruby/sqlite3/pragmas.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/pragmas.rb index b2dc199c..52bda1a1 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/pragmas.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/pragmas.rb @@ -1,35 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'sqlite3/errors' module SQLite3 @@ -54,8 +22,8 @@ module SQLite3 case mode when String case mode.downcase - when "on", "yes", "true", "y", "t" then mode = "'ON'" - when "off", "no", "false", "n", "f" then mode = "'OFF'" + when "on", "yes", "true", "y", "t"; mode = "'ON'" + when "off", "no", "false", "n", "f"; mode = "'OFF'" else raise Exception, "unrecognized pragma parameter #{mode.inspect}" @@ -290,10 +258,12 @@ module SQLite3 # unquotes those values. def tweak_default(hash) case hash["dflt_value"] - when /^null$/i then + when /^null$/i hash["dflt_value"] = nil when /^'(.*)'$/ hash["dflt_value"] = $1.gsub(/''/, "'") + when /^"(.*)"$/ + hash["dflt_value"] = $1.gsub(/""/, '"') end end end diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/resultset.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb similarity index 61% rename from vendor/plugins/sqlite3-ruby/sqlite3/resultset.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb index ed2cb582..5da10f52 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/resultset.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/resultset.rb @@ -1,35 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'sqlite3/constants' require 'sqlite3/errors' @@ -42,16 +10,25 @@ module SQLite3 class ResultSet include Enumerable - # A trivial module for adding a +types+ accessor to an object. - module TypesContainer + # The class of which we return an object in case we want an Array as + # result. (ArrayFields is installed.) + class ArrayWithTypes < Array attr_accessor :types end - # A trivial module for adding a +fields+ accessor to an object. - module FieldsContainer + # The class of which we return an object in case we want an Array as + # result. (ArrayFields is not installed.) + class ArrayWithTypesAndFields < Array + attr_accessor :types attr_accessor :fields end + # The class of which we return an object in case we want a Hash as + # result. + class HashWithTypes < Hash + attr_accessor :types + end + # Create a new ResultSet attached to the given database, using the # given sql text. def initialize( db, stmt ) @@ -65,6 +42,9 @@ module SQLite3 # to the first row of the result set. def commence result = @driver.step( @stmt.handle ) + if result == Constants::ErrorCode::ERROR + @driver.reset( @stmt.handle ) + end check result @first_row = true end @@ -121,13 +101,16 @@ module SQLite3 unless @eof row = [] @driver.data_count( @stmt.handle ).times do |column| - case @driver.column_type( @stmt.handle, column ) - when Constants::ColumnType::NULL then - row << nil - when Constants::ColumnType::BLOB then - row << @driver.column_blob( @stmt.handle, column ) - else - row << @driver.column_text( @stmt.handle, column ) + type = @driver.column_type( @stmt.handle, column ) + + if type == Constants::ColumnType::TEXT + row << @driver.column_text( @stmt.handle, column ) + elsif type == Constants::ColumnType::NULL + row << nil + elsif type == Constants::ColumnType::BLOB + row << @driver.column_blob( @stmt.handle, column ) + else + row << @driver.column_text( @stmt.handle, column ) end end @@ -138,15 +121,18 @@ module SQLite3 end if @db.results_as_hash - new_row = Hash[ *( @stmt.columns.zip( row ).flatten ) ] + new_row = HashWithTypes[ *( @stmt.columns.zip( row ).to_a.flatten ) ] row.each_with_index { |value,idx| new_row[idx] = value } row = new_row else - row.extend FieldsContainer unless row.respond_to?(:fields) + if row.respond_to?(:fields) + row = ArrayWithTypes.new(row) + else + row = ArrayWithTypesAndFields.new(row) + end row.fields = @stmt.columns end - row.extend TypesContainer row.types = @stmt.types return row diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/statement.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb similarity index 78% rename from vendor/plugins/sqlite3-ruby/sqlite3/statement.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb index 09f24d91..eeca6a2b 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/statement.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/statement.rb @@ -1,35 +1,3 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'sqlite3/errors' require 'sqlite3/resultset' @@ -122,7 +90,11 @@ module SQLite3 when Bignum then @driver.bind_int64( @handle, param, value ) when Integer then - @driver.bind_int( @handle, param, value ) + if value >= (2 ** 31) + @driver.bind_int64( @handle, param, value ) + else + @driver.bind_int( @handle, param, value ) + end when Numeric then @driver.bind_double( @handle, param, value.to_f ) when Blob then diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/translator.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/translator.rb similarity index 62% rename from vendor/plugins/sqlite3-ruby/sqlite3/translator.rb rename to vendor/plugins/sqlite3-ruby/lib/sqlite3/translator.rb index 14d28b6c..1635e982 100644 --- a/vendor/plugins/sqlite3-ruby/sqlite3/translator.rb +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/translator.rb @@ -1,36 +1,5 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - require 'time' +require 'date' module SQLite3 @@ -48,6 +17,7 @@ module SQLite3 # translators for most SQL data types. def initialize @translators = Hash.new( proc { |type,value| value } ) + @type_name_cache = {} register_default_translators end @@ -81,18 +51,22 @@ module SQLite3 # A convenience method for working with type names. This returns the "base" # type name, without any parenthetical data. def type_name( type ) - return "" if type.nil? - type = $1 if type =~ /^(.*?)\(/ - type.upcase + @type_name_cache[type] ||= begin + type = "" if type.nil? + type = $1 if type =~ /^(.*?)\(/ + type.upcase + end end private :type_name # Register the default translators for the current Translator instance. # This includes translators for most major SQL data types. def register_default_translators - [ "date", - "datetime", - "time" ].each { |type| add_translator( type ) { |t,v| Time.parse( v ) } } + [ "time", + "timestamp" ].each { |type| add_translator( type ) { |t, v| Time.parse( v ) } } + + add_translator( "date" ) { |t,v| Date.parse(v) } + add_translator( "datetime" ) { |t,v| DateTime.parse(v) } [ "decimal", "float", @@ -120,7 +94,6 @@ module SQLite3 end end - add_translator( "timestamp" ) { |type, value| Time.at( value.to_i ) } add_translator( "tinyint" ) do |type, value| if type =~ /\(\s*1\s*\)/ value.to_i == 1 diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/value.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/value.rb new file mode 100644 index 00000000..e5e5bf2c --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/value.rb @@ -0,0 +1,57 @@ +require 'sqlite3/constants' + +module SQLite3 + + class Value + attr_reader :handle + + def initialize( db, handle ) + @driver = db.driver + @handle = handle + end + + def null? + type == :null + end + + def to_blob + @driver.value_blob( @handle ) + end + + def length( utf16=false ) + if utf16 + @driver.value_bytes16( @handle ) + else + @driver.value_bytes( @handle ) + end + end + + def to_f + @driver.value_double( @handle ) + end + + def to_i + @driver.value_int( @handle ) + end + + def to_int64 + @driver.value_int64( @handle ) + end + + def to_s( utf16=false ) + @driver.value_text( @handle, utf16 ) + end + + def type + case @driver.value_type( @handle ) + when Constants::ColumnType::INTEGER then :int + when Constants::ColumnType::FLOAT then :float + when Constants::ColumnType::TEXT then :text + when Constants::ColumnType::BLOB then :blob + when Constants::ColumnType::NULL then :null + end + end + + end + +end diff --git a/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb b/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb new file mode 100644 index 00000000..24465445 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/lib/sqlite3/version.rb @@ -0,0 +1,14 @@ +module SQLite3 + + module Version + + MAJOR = 1 + MINOR = 2 + TINY = 4 + + STRING = [ MAJOR, MINOR, TINY ].join( "." ) + #:beta-tag: + + end + +end diff --git a/vendor/plugins/sqlite3-ruby/setup.rb b/vendor/plugins/sqlite3-ruby/setup.rb new file mode 100644 index 00000000..5f22fc1f --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/setup.rb @@ -0,0 +1,1333 @@ +# +# setup.rb +# +# Copyright (c) 2000-2004 Minero Aoki +# +# This program is free software. +# You can distribute/modify this program under the terms of +# the GNU LGPL, Lesser General Public License version 2.1. +# + +# +# For backward compatibility +# + +unless Enumerable.method_defined?(:map) + module Enumerable + alias map collect + end +end + +unless Enumerable.method_defined?(:detect) + module Enumerable + alias detect find + end +end + +unless Enumerable.method_defined?(:select) + module Enumerable + alias select find_all + end +end + +unless Enumerable.method_defined?(:reject) + module Enumerable + def reject + select {|i| not yield(i) } + end + end +end + +unless Enumerable.method_defined?(:inject) + module Enumerable + def inject(result) + each do |i| + result = yield(result, i) + end + result + end + end +end + +unless Enumerable.method_defined?(:any?) + module Enumerable + def any? + each do |i| + return true if yield(i) + end + false + end + end +end + +unless File.respond_to?(:read) + def File.read(fname) + open(fname) {|f| + return f.read + } + end +end + +# +# Application independent utilities +# + +def File.binread(fname) + open(fname, 'rb') {|f| + return f.read + } +end + +# for corrupted windows stat(2) +def File.dir?(path) + File.directory?((path[-1,1] == '/') ? path : path + '/') +end + +# +# Config +# + +if arg = ARGV.detect {|arg| /\A--rbconfig=/ =~ arg } + ARGV.delete(arg) + require arg.split(/=/, 2)[1] + $".push 'rbconfig.rb' +else + require 'rbconfig' +end + +def multipackage_install? + FileTest.directory?(File.dirname($0) + '/packages') +end + + +class ConfigTable + + c = ::Config::CONFIG + + rubypath = c['bindir'] + '/' + c['ruby_install_name'] + + major = c['MAJOR'].to_i + minor = c['MINOR'].to_i + teeny = c['TEENY'].to_i + version = "#{major}.#{minor}" + + # ruby ver. >= 1.4.4? + newpath_p = ((major >= 2) or + ((major == 1) and + ((minor >= 5) or + ((minor == 4) and (teeny >= 4))))) + + subprefix = lambda {|path| + path.sub(/\A#{Regexp.quote(c['prefix'])}/o, '$prefix') + } + + if c['rubylibdir'] + # V < 1.6.3 + stdruby = subprefix.call(c['rubylibdir']) + siteruby = subprefix.call(c['sitedir']) + versite = subprefix.call(c['sitelibdir']) + sodir = subprefix.call(c['sitearchdir']) + elsif newpath_p + # 1.4.4 <= V <= 1.6.3 + stdruby = "$prefix/lib/ruby/#{version}" + siteruby = subprefix.call(c['sitedir']) + versite = siteruby + '/' + version + sodir = "$site-ruby/#{c['arch']}" + else + # V < 1.4.4 + stdruby = "$prefix/lib/ruby/#{version}" + siteruby = "$prefix/lib/ruby/#{version}/site_ruby" + versite = siteruby + sodir = "$site-ruby/#{c['arch']}" + end + + if arg = c['configure_args'].split.detect {|arg| /--with-make-prog=/ =~ arg } + makeprog = arg.sub(/'/, '').split(/=/, 2)[1] + else + makeprog = 'make' + end + + common_descripters = [ + [ 'prefix', [ c['prefix'], + 'path', + 'path prefix of target environment' ] ], + [ 'std-ruby', [ stdruby, + 'path', + 'the directory for standard ruby libraries' ] ], + [ 'site-ruby-common', [ siteruby, + 'path', + 'the directory for version-independent non-standard ruby libraries' ] ], + [ 'site-ruby', [ versite, + 'path', + 'the directory for non-standard ruby libraries' ] ], + [ 'bin-dir', [ '$prefix/bin', + 'path', + 'the directory for commands' ] ], + [ 'rb-dir', [ '$site-ruby', + 'path', + 'the directory for ruby scripts' ] ], + [ 'so-dir', [ sodir, + 'path', + 'the directory for ruby extentions' ] ], + [ 'data-dir', [ '$prefix/share', + 'path', + 'the directory for shared data' ] ], + [ 'ruby-path', [ rubypath, + 'path', + 'path to set to #! line' ] ], + [ 'ruby-prog', [ rubypath, + 'name', + 'the ruby program using for installation' ] ], + [ 'make-prog', [ makeprog, + 'name', + 'the make program to compile ruby extentions' ] ], + [ 'without-ext', [ 'no', + 'yes/no', + 'does not compile/install ruby extentions' ] ] + ] + multipackage_descripters = [ + [ 'with', [ '', + 'name,name...', + 'package names that you want to install', + 'ALL' ] ], + [ 'without', [ '', + 'name,name...', + 'package names that you do not want to install', + 'NONE' ] ] + ] + if multipackage_install? + DESCRIPTER = common_descripters + multipackage_descripters + else + DESCRIPTER = common_descripters + end + + SAVE_FILE = '.config' + + def ConfigTable.each_name(&block) + keys().each(&block) + end + + def ConfigTable.keys + DESCRIPTER.map {|name, *dummy| name } + end + + def ConfigTable.each_definition(&block) + DESCRIPTER.each(&block) + end + + def ConfigTable.get_entry(name) + name, ent = DESCRIPTER.assoc(name) + ent + end + + def ConfigTable.get_entry!(name) + get_entry(name) or raise ArgumentError, "no such config: #{name}" + end + + def ConfigTable.add_entry(name, vals) + ConfigTable::DESCRIPTER.push [name,vals] + end + + def ConfigTable.remove_entry(name) + get_entry(name) or raise ArgumentError, "no such config: #{name}" + DESCRIPTER.delete_if {|n, arr| n == name } + end + + def ConfigTable.config_key?(name) + get_entry(name) ? true : false + end + + def ConfigTable.bool_config?(name) + ent = get_entry(name) or return false + ent[1] == 'yes/no' + end + + def ConfigTable.value_config?(name) + ent = get_entry(name) or return false + ent[1] != 'yes/no' + end + + def ConfigTable.path_config?(name) + ent = get_entry(name) or return false + ent[1] == 'path' + end + + + class << self + alias newobj new + end + + def ConfigTable.new + c = newobj() + c.initialize_from_table + c + end + + def ConfigTable.load + c = newobj() + c.initialize_from_file + c + end + + def initialize_from_table + @table = {} + DESCRIPTER.each do |k, (default, vname, desc, default2)| + @table[k] = default + end + end + + def initialize_from_file + raise InstallError, "#{File.basename $0} config first"\ + unless File.file?(SAVE_FILE) + @table = {} + File.foreach(SAVE_FILE) do |line| + k, v = line.split(/=/, 2) + @table[k] = v.strip + end + end + + def save + File.open(SAVE_FILE, 'w') {|f| + @table.each do |k, v| + f.printf "%s=%s\n", k, v if v + end + } + end + + def []=(k, v) + raise InstallError, "unknown config option #{k}"\ + unless ConfigTable.config_key?(k) + @table[k] = v + end + + def [](key) + return nil unless @table[key] + @table[key].gsub(%r<\$([^/]+)>) { self[$1] } + end + + def set_raw(key, val) + @table[key] = val + end + + def get_raw(key) + @table[key] + end + +end + + +module MetaConfigAPI + + def eval_file_ifexist(fname) + instance_eval File.read(fname), fname, 1 if File.file?(fname) + end + + def config_names + ConfigTable.keys + end + + def config?(name) + ConfigTable.config_key?(name) + end + + def bool_config?(name) + ConfigTable.bool_config?(name) + end + + def value_config?(name) + ConfigTable.value_config?(name) + end + + def path_config?(name) + ConfigTable.path_config?(name) + end + + def add_config(name, argname, default, desc) + ConfigTable.add_entry name,[default,argname,desc] + end + + def add_path_config(name, default, desc) + add_config name, 'path', default, desc + end + + def add_bool_config(name, default, desc) + add_config name, 'yes/no', default ? 'yes' : 'no', desc + end + + def set_config_default(name, default) + if bool_config?(name) + ConfigTable.get_entry!(name)[0] = (default ? 'yes' : 'no') + else + ConfigTable.get_entry!(name)[0] = default + end + end + + def remove_config(name) + ent = ConfigTable.get_entry(name) + ConfigTable.remove_entry name + ent + end + +end + +# +# File Operations +# + +module FileOperations + + def mkdir_p(dirname, prefix = nil) + dirname = prefix + dirname if prefix + $stderr.puts "mkdir -p #{dirname}" if verbose? + return if no_harm? + + # does not check '/'... it's too abnormal case + dirs = dirname.split(%r<(?=/)>) + if /\A[a-z]:\z/i =~ dirs[0] + disk = dirs.shift + dirs[0] = disk + dirs[0] + end + dirs.each_index do |idx| + path = dirs[0..idx].join('') + Dir.mkdir path unless File.dir?(path) + end + end + + def rm_f(fname) + $stderr.puts "rm -f #{fname}" if verbose? + return if no_harm? + + if File.exist?(fname) or File.symlink?(fname) + File.chmod 0777, fname + File.unlink fname + end + end + + def rm_rf(dn) + $stderr.puts "rm -rf #{dn}" if verbose? + return if no_harm? + + Dir.chdir dn + Dir.foreach('.') do |fn| + next if fn == '.' + next if fn == '..' + if File.dir?(fn) + verbose_off { + rm_rf fn + } + else + verbose_off { + rm_f fn + } + end + end + Dir.chdir '..' + Dir.rmdir dn + end + + def move_file(src, dest) + File.unlink dest if File.exist?(dest) + begin + File.rename src, dest + rescue + File.open(dest, 'wb') {|f| f.write File.binread(src) } + File.chmod File.stat(src).mode, dest + File.unlink src + end + end + + def install(from, dest, mode, prefix = nil) + $stderr.puts "install #{from} #{dest}" if verbose? + return if no_harm? + + realdest = prefix ? prefix + dest : dest + realdest = File.join(realdest, File.basename(from)) if File.dir?(realdest) + str = File.binread(from) + if diff?(str, realdest) + verbose_off { + rm_f realdest if File.exist?(realdest) + } + File.open(realdest, 'wb') {|f| + f.write str + } + File.chmod mode, realdest + + File.open("#{objdir_root()}/InstalledFiles", 'a') {|f| + if prefix + f.puts realdest.sub(prefix, '') + else + f.puts realdest + end + } + end + end + + def diff?(new_content, path) + return true unless File.exist?(path) + new_content != File.binread(path) + end + + def command(str) + $stderr.puts str if verbose? + system str or raise RuntimeError, "'system #{str}' failed" + end + + def ruby(str) + command config('ruby-prog') + ' ' + str + end + + def make(task = '') + command config('make-prog') + ' ' + task + end + + def extdir?(dir) + File.exist?(dir + '/MANIFEST') + end + + def all_files_in(dirname) + Dir.open(dirname) {|d| + return d.select {|ent| File.file?("#{dirname}/#{ent}") } + } + end + + REJECT_DIRS = %w( + CVS SCCS RCS CVS.adm .svn + ) + + def all_dirs_in(dirname) + Dir.open(dirname) {|d| + return d.select {|n| File.dir?("#{dirname}/#{n}") } - %w(. ..) - REJECT_DIRS + } + end + +end + +# +# Main Installer +# + +class InstallError < StandardError; end + + +module HookUtils + + def run_hook(name) + try_run_hook "#{curr_srcdir()}/#{name}" or + try_run_hook "#{curr_srcdir()}/#{name}.rb" + end + + def try_run_hook(fname) + return false unless File.file?(fname) + begin + instance_eval File.read(fname), fname, 1 + rescue + raise InstallError, "hook #{fname} failed:\n" + $!.message + end + true + end + +end + + +module HookScriptAPI + + def get_config(key) + @config[key] + end + + alias config get_config + + def set_config(key, val) + @config[key] = val + end + + # + # srcdir/objdir (works only in the package directory) + # + + #abstract srcdir_root + #abstract objdir_root + #abstract relpath + + def curr_srcdir + "#{srcdir_root()}/#{relpath()}" + end + + def curr_objdir + "#{objdir_root()}/#{relpath()}" + end + + def srcfile(path) + "#{curr_srcdir()}/#{path}" + end + + def srcexist?(path) + File.exist?(srcfile(path)) + end + + def srcdirectory?(path) + File.dir?(srcfile(path)) + end + + def srcfile?(path) + File.file? srcfile(path) + end + + def srcentries(path = '.') + Dir.open("#{curr_srcdir()}/#{path}") {|d| + return d.to_a - %w(. ..) + } + end + + def srcfiles(path = '.') + srcentries(path).select {|fname| + File.file?(File.join(curr_srcdir(), path, fname)) + } + end + + def srcdirectories(path = '.') + srcentries(path).select {|fname| + File.dir?(File.join(curr_srcdir(), path, fname)) + } + end + +end + + +class ToplevelInstaller + + Version = '3.3.0' + Copyright = 'Copyright (c) 2000-2004 Minero Aoki' + + TASKS = [ + [ 'all', 'do config, setup, then install' ], + [ 'config', 'saves your configurations' ], + [ 'show', 'shows current configuration' ], + [ 'setup', 'compiles ruby extentions and others' ], + [ 'install', 'installs files' ], + [ 'clean', "does `make clean' for each extention" ], + [ 'distclean',"does `make distclean' for each extention" ] + ] + + def ToplevelInstaller.invoke + instance().invoke + end + + @singleton = nil + + def ToplevelInstaller.instance + @singleton ||= new(File.dirname($0)) + @singleton + end + + include MetaConfigAPI + + def initialize(ardir_root) + @config = nil + @options = { 'verbose' => true } + @ardir = File.expand_path(ardir_root) + end + + def inspect + "#<#{self.class} #{__id__()}>" + end + + def invoke + run_metaconfigs + case task = parsearg_global() + when nil, 'all' + @config = load_config('config') + parsearg_config + init_installers + exec_config + exec_setup + exec_install + else + @config = load_config(task) + __send__ "parsearg_#{task}" + init_installers + __send__ "exec_#{task}" + end + end + + def run_metaconfigs + eval_file_ifexist "#{@ardir}/metaconfig" + end + + def load_config(task) + case task + when 'config' + ConfigTable.new + when 'clean', 'distclean' + if File.exist?(ConfigTable::SAVE_FILE) + then ConfigTable.load + else ConfigTable.new + end + else + ConfigTable.load + end + end + + def init_installers + @installer = Installer.new(@config, @options, @ardir, File.expand_path('.')) + end + + # + # Hook Script API bases + # + + def srcdir_root + @ardir + end + + def objdir_root + '.' + end + + def relpath + '.' + end + + # + # Option Parsing + # + + def parsearg_global + valid_task = /\A(?:#{TASKS.map {|task,desc| task }.join '|'})\z/ + + while arg = ARGV.shift + case arg + when /\A\w+\z/ + raise InstallError, "invalid task: #{arg}" unless valid_task =~ arg + return arg + + when '-q', '--quiet' + @options['verbose'] = false + + when '--verbose' + @options['verbose'] = true + + when '-h', '--help' + print_usage $stdout + exit 0 + + when '-v', '--version' + puts "#{File.basename($0)} version #{Version}" + exit 0 + + when '--copyright' + puts Copyright + exit 0 + + else + raise InstallError, "unknown global option '#{arg}'" + end + end + + nil + end + + + def parsearg_no_options + raise InstallError, "#{task}: unknown options: #{ARGV.join ' '}"\ + unless ARGV.empty? + end + + alias parsearg_show parsearg_no_options + alias parsearg_setup parsearg_no_options + alias parsearg_clean parsearg_no_options + alias parsearg_distclean parsearg_no_options + + def parsearg_config + re = /\A--(#{ConfigTable.keys.join '|'})(?:=(.*))?\z/ + @options['config-opt'] = [] + + while i = ARGV.shift + if /\A--?\z/ =~ i + @options['config-opt'] = ARGV.dup + break + end + m = re.match(i) or raise InstallError, "config: unknown option #{i}" + name, value = m.to_a[1,2] + if value + if ConfigTable.bool_config?(name) + raise InstallError, "config: --#{name} allows only yes/no for argument"\ + unless /\A(y(es)?|n(o)?|t(rue)?|f(alse))\z/i =~ value + value = (/\Ay(es)?|\At(rue)/i =~ value) ? 'yes' : 'no' + end + else + raise InstallError, "config: --#{name} requires argument"\ + unless ConfigTable.bool_config?(name) + value = 'yes' + end + @config[name] = value + end + end + + def parsearg_install + @options['no-harm'] = false + @options['install-prefix'] = '' + while a = ARGV.shift + case a + when /\A--no-harm\z/ + @options['no-harm'] = true + when /\A--prefix=(.*)\z/ + path = $1 + path = File.expand_path(path) unless path[0,1] == '/' + @options['install-prefix'] = path + else + raise InstallError, "install: unknown option #{a}" + end + end + end + + def print_usage(out) + out.puts 'Typical Installation Procedure:' + out.puts " $ ruby #{File.basename $0} config" + out.puts " $ ruby #{File.basename $0} setup" + out.puts " # ruby #{File.basename $0} install (may require root privilege)" + out.puts + out.puts 'Detailed Usage:' + out.puts " ruby #{File.basename $0} " + out.puts " ruby #{File.basename $0} [] []" + + fmt = " %-20s %s\n" + out.puts + out.puts 'Global options:' + out.printf fmt, '-q,--quiet', 'suppress message outputs' + out.printf fmt, ' --verbose', 'output messages verbosely' + out.printf fmt, '-h,--help', 'print this message' + out.printf fmt, '-v,--version', 'print version and quit' + out.printf fmt, ' --copyright', 'print copyright and quit' + + out.puts + out.puts 'Tasks:' + TASKS.each do |name, desc| + out.printf " %-10s %s\n", name, desc + end + + out.puts + out.puts 'Options for CONFIG or ALL:' + ConfigTable.each_definition do |name, (default, arg, desc, default2)| + out.printf " %-20s %s [%s]\n", + '--'+ name + (ConfigTable.bool_config?(name) ? '' : '='+arg), + desc, + default2 || default + end + out.printf " %-20s %s [%s]\n", + '--rbconfig=path', 'your rbconfig.rb to load', "running ruby's" + + out.puts + out.puts 'Options for INSTALL:' + out.printf " %-20s %s [%s]\n", + '--no-harm', 'only display what to do if given', 'off' + out.printf " %-20s %s [%s]\n", + '--prefix', 'install path prefix', '$prefix' + + out.puts + end + + # + # Task Handlers + # + + def exec_config + @installer.exec_config + @config.save # must be final + end + + def exec_setup + @installer.exec_setup + end + + def exec_install + @installer.exec_install + end + + def exec_show + ConfigTable.each_name do |k| + v = @config.get_raw(k) + if not v or v.empty? + v = '(not specified)' + end + printf "%-10s %s\n", k, v + end + end + + def exec_clean + @installer.exec_clean + end + + def exec_distclean + @installer.exec_distclean + end + +end + + +class ToplevelInstallerMulti < ToplevelInstaller + + include HookUtils + include HookScriptAPI + include FileOperations + + def initialize(ardir) + super + @packages = all_dirs_in("#{@ardir}/packages") + raise 'no package exists' if @packages.empty? + end + + def run_metaconfigs + eval_file_ifexist "#{@ardir}/metaconfig" + @packages.each do |name| + eval_file_ifexist "#{@ardir}/packages/#{name}/metaconfig" + end + end + + def init_installers + @installers = {} + @packages.each do |pack| + @installers[pack] = Installer.new(@config, @options, + "#{@ardir}/packages/#{pack}", + "packages/#{pack}") + end + + with = extract_selection(config('with')) + without = extract_selection(config('without')) + @selected = @installers.keys.select {|name| + (with.empty? or with.include?(name)) \ + and not without.include?(name) + } + end + + def extract_selection(list) + a = list.split(/,/) + a.each do |name| + raise InstallError, "no such package: #{name}" \ + unless @installers.key?(name) + end + a + end + + def print_usage(f) + super + f.puts 'Inluded packages:' + f.puts ' ' + @packages.sort.join(' ') + f.puts + end + + # + # multi-package metaconfig API + # + + attr_reader :packages + + def declare_packages(list) + raise 'package list is empty' if list.empty? + list.each do |name| + raise "directory packages/#{name} does not exist"\ + unless File.dir?("#{@ardir}/packages/#{name}") + end + @packages = list + end + + # + # Task Handlers + # + + def exec_config + run_hook 'pre-config' + each_selected_installers {|inst| inst.exec_config } + run_hook 'post-config' + @config.save # must be final + end + + def exec_setup + run_hook 'pre-setup' + each_selected_installers {|inst| inst.exec_setup } + run_hook 'post-setup' + end + + def exec_install + run_hook 'pre-install' + each_selected_installers {|inst| inst.exec_install } + run_hook 'post-install' + end + + def exec_clean + rm_f ConfigTable::SAVE_FILE + run_hook 'pre-clean' + each_selected_installers {|inst| inst.exec_clean } + run_hook 'post-clean' + end + + def exec_distclean + rm_f ConfigTable::SAVE_FILE + run_hook 'pre-distclean' + each_selected_installers {|inst| inst.exec_distclean } + run_hook 'post-distclean' + end + + # + # lib + # + + def each_selected_installers + Dir.mkdir 'packages' unless File.dir?('packages') + @selected.each do |pack| + $stderr.puts "Processing the package `#{pack}' ..." if @options['verbose'] + Dir.mkdir "packages/#{pack}" unless File.dir?("packages/#{pack}") + Dir.chdir "packages/#{pack}" + yield @installers[pack] + Dir.chdir '../..' + end + end + + def verbose? + @options['verbose'] + end + + def no_harm? + @options['no-harm'] + end + +end + + +class Installer + + FILETYPES = %w( bin lib ext data ) + + include HookScriptAPI + include HookUtils + include FileOperations + + def initialize(config, opt, srcroot, objroot) + @config = config + @options = opt + @srcdir = File.expand_path(srcroot) + @objdir = File.expand_path(objroot) + @currdir = '.' + end + + def inspect + "#<#{self.class} #{File.basename(@srcdir)}>" + end + + # + # Hook Script API bases + # + + def srcdir_root + @srcdir + end + + def objdir_root + @objdir + end + + def relpath + @currdir + end + + # + # configs/options + # + + def no_harm? + @options['no-harm'] + end + + def verbose? + @options['verbose'] + end + + def verbose_off + begin + save, @options['verbose'] = @options['verbose'], false + yield + ensure + @options['verbose'] = save + end + end + + # + # TASK config + # + + def exec_config + exec_task_traverse 'config' + end + + def config_dir_bin(rel) + end + + def config_dir_lib(rel) + end + + def config_dir_ext(rel) + extconf if extdir?(curr_srcdir()) + end + + def extconf + opt = @options['config-opt'].join(' ') + command "#{config('ruby-prog')} #{curr_srcdir()}/extconf.rb #{opt}" + end + + def config_dir_data(rel) + end + + # + # TASK setup + # + + def exec_setup + exec_task_traverse 'setup' + end + + def setup_dir_bin(rel) + all_files_in(curr_srcdir()).each do |fname| + adjust_shebang "#{curr_srcdir()}/#{fname}" + end + end + + def adjust_shebang(path) + return if no_harm? + tmpfile = File.basename(path) + '.tmp' + begin + File.open(path, 'rb') {|r| + File.open(tmpfile, 'wb') {|w| + first = r.gets + return unless should_modify_shebang?(first) + $stderr.puts "adjusting shebang: #{File.basename(path)}" if verbose? + w.print first.sub(SHEBANG_RE, '#!' + config('ruby-path')) + w.write r.read + } + } + move_file tmpfile, File.basename(path) + ensure + File.unlink tmpfile if File.exist?(tmpfile) + end + end + + def should_modify_shebang?(line) + File.basename(config('ruby-path')) == 'ruby' or + shebang_command(line) == 'ruby' + end + + def shebang_command(line) + cmd, arg = *line.sub(/\A\#!/, '').strip.split(/\s+/, 2) + cmd + end + + def setup_dir_lib(rel) + end + + def setup_dir_ext(rel) + make if extdir?(curr_srcdir()) + end + + def setup_dir_data(rel) + end + + # + # TASK install + # + + def exec_install + exec_task_traverse 'install' + end + + def install_dir_bin(rel) + install_files collect_filenames_auto(), "#{config('bin-dir')}/#{rel}", 0755 + end + + def install_dir_lib(rel) + install_files ruby_scripts(), "#{config('rb-dir')}/#{rel}", 0644 + end + + def install_dir_ext(rel) + return unless extdir?(curr_srcdir()) + install_files ruby_extentions('.'), + "#{config('so-dir')}/#{File.dirname(rel)}", + 0555 + end + + def install_dir_data(rel) + install_files collect_filenames_auto(), "#{config('data-dir')}/#{rel}", 0644 + end + + def install_files(list, dest, mode) + mkdir_p dest, @options['install-prefix'] + list.each do |fname| + install fname, dest, mode, @options['install-prefix'] + end + end + + def ruby_scripts + collect_filenames_auto().select {|n| /\.rb\z/ =~ n } + end + + # picked up many entries from cvs-1.11.1/src/ignore.c + reject_patterns = %w( + core RCSLOG tags TAGS .make.state + .nse_depinfo #* .#* cvslog.* ,* .del-* *.olb + *~ *.old *.bak *.BAK *.orig *.rej _$* *$ + + *.org *.in .* + ) + mapping = { + '.' => '\.', + '$' => '\$', + '#' => '\#', + '*' => '.*' + } + REJECT_PATTERNS = Regexp.new('\A(?:' + + reject_patterns.map {|pat| + pat.gsub(/[\.\$\#\*]/) {|ch| mapping[ch] } + }.join('|') + + ')\z') + + def collect_filenames_auto + mapdir((existfiles() - hookfiles()).reject {|fname| + REJECT_PATTERNS =~ fname + }) + end + + def existfiles + all_files_in(curr_srcdir()) | all_files_in('.') + end + + def hookfiles + %w( pre-%s post-%s pre-%s.rb post-%s.rb ).map {|fmt| + %w( config setup install clean ).map {|t| sprintf(fmt, t) } + }.flatten + end + + def mapdir(filelist) + filelist.map {|fname| + if File.exist?(fname) # objdir + fname + else # srcdir + File.join(curr_srcdir(), fname) + end + } + end + + def ruby_extentions(dir) + _ruby_extentions(dir) or + raise InstallError, "no ruby extention exists: 'ruby #{$0} setup' first" + end + + DLEXT = /\.#{ ::Config::CONFIG['DLEXT'] }\z/ + + def _ruby_extentions(dir) + Dir.open(dir) {|d| + return d.select {|fname| DLEXT =~ fname } + } + end + + # + # TASK clean + # + + def exec_clean + exec_task_traverse 'clean' + rm_f ConfigTable::SAVE_FILE + rm_f 'InstalledFiles' + end + + def clean_dir_bin(rel) + end + + def clean_dir_lib(rel) + end + + def clean_dir_ext(rel) + return unless extdir?(curr_srcdir()) + make 'clean' if File.file?('Makefile') + end + + def clean_dir_data(rel) + end + + # + # TASK distclean + # + + def exec_distclean + exec_task_traverse 'distclean' + rm_f ConfigTable::SAVE_FILE + rm_f 'InstalledFiles' + end + + def distclean_dir_bin(rel) + end + + def distclean_dir_lib(rel) + end + + def distclean_dir_ext(rel) + return unless extdir?(curr_srcdir()) + make 'distclean' if File.file?('Makefile') + end + + # + # lib + # + + def exec_task_traverse(task) + run_hook "pre-#{task}" + FILETYPES.each do |type| + if config('without-ext') == 'yes' and type == 'ext' + $stderr.puts 'skipping ext/* by user option' if verbose? + next + end + traverse task, type, "#{task}_dir_#{type}" + end + run_hook "post-#{task}" + end + + def traverse(task, rel, mid) + dive_into(rel) { + run_hook "pre-#{task}" + __send__ mid, rel.sub(%r[\A.*?(?:/|\z)], '') + all_dirs_in(curr_srcdir()).each do |d| + traverse task, "#{rel}/#{d}", mid + end + run_hook "post-#{task}" + } + end + + def dive_into(rel) + return unless File.dir?("#{@srcdir}/#{rel}") + + dir = File.basename(rel) + Dir.mkdir dir unless File.dir?(dir) + prevdir = Dir.pwd + Dir.chdir dir + $stderr.puts '---> ' + rel if verbose? + @currdir = rel + yield + Dir.chdir prevdir + $stderr.puts '<--- ' + rel if verbose? + @currdir = File.dirname(rel) + end + +end + + +if $0 == __FILE__ + begin + if multipackage_install? + ToplevelInstallerMulti.invoke + else + ToplevelInstaller.invoke + end + rescue + raise if $DEBUG + $stderr.puts $!.message + $stderr.puts "Try 'ruby #{$0} --help' for detailed usage." + exit 1 + end +end diff --git a/vendor/plugins/sqlite3-ruby/sqlite3.rb b/vendor/plugins/sqlite3-ruby/sqlite3.rb deleted file mode 100644 index ff8af026..00000000 --- a/vendor/plugins/sqlite3-ruby/sqlite3.rb +++ /dev/null @@ -1,33 +0,0 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - -require 'sqlite3/database' diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/value.rb b/vendor/plugins/sqlite3-ruby/sqlite3/value.rb deleted file mode 100644 index fb763763..00000000 --- a/vendor/plugins/sqlite3-ruby/sqlite3/value.rb +++ /dev/null @@ -1,89 +0,0 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - -require 'sqlite3/constants' - -module SQLite3 - - class Value - attr_reader :handle - - def initialize( db, handle ) - @driver = db.driver - @handle = handle - end - - def null? - type == :null - end - - def to_blob - @driver.value_blob( @handle ) - end - - def length( utf16=false ) - if utf16 - @driver.value_bytes16( @handle ) - else - @driver.value_bytes( @handle ) - end - end - - def to_f - @driver.value_double( @handle ) - end - - def to_i - @driver.value_int( @handle ) - end - - def to_int64 - @driver.value_int64( @handle ) - end - - def to_s( utf16=false ) - @driver.value_text( @handle, utf16 ) - end - - def type - case @driver.value_type( @handle ) - when Constants::ColumnType::INTEGER then :int - when Constants::ColumnType::FLOAT then :float - when Constants::ColumnType::TEXT then :text - when Constants::ColumnType::BLOB then :blob - when Constants::ColumnType::NULL then :null - end - end - - end - -end diff --git a/vendor/plugins/sqlite3-ruby/sqlite3/version.rb b/vendor/plugins/sqlite3-ruby/sqlite3/version.rb deleted file mode 100644 index 2398c0ac..00000000 --- a/vendor/plugins/sqlite3-ruby/sqlite3/version.rb +++ /dev/null @@ -1,46 +0,0 @@ -#-- -# ============================================================================= -# Copyright (c) 2004, Jamis Buck (jgb3@email.byu.edu) -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are met: -# -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# * Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# * The names of its contributors may not be used to endorse or promote -# products derived from this software without specific prior written -# permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE -# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -# ============================================================================= -#++ - -module SQLite3 - - module Version - - MAJOR = 1 - MINOR = 2 - TINY = 1 - - STRING = [ MAJOR, MINOR, TINY ].join( "." ) - #:beta-tag: - - end - -end diff --git a/vendor/plugins/sqlite3-ruby/test/bm.rb b/vendor/plugins/sqlite3-ruby/test/bm.rb new file mode 100644 index 00000000..aacb4a12 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/bm.rb @@ -0,0 +1,140 @@ +require 'benchmark' + +N = 1000 + +$VERBOSE=nil + +puts "file require" +Benchmark.bm( 7 ) do |x| + x.report('sqlite') do + N.times do + $".delete_if { |i| i =~ /sqlite/ } + require 'sqlite' + end + end + x.report('sqlite3') do + N.times do + $".delete_if { |i| i =~ /sqlite3/ } + require 'sqlite3' + end + end +end + +puts +puts "database creation..." +Benchmark.bm( 7 ) do |x| + x.report('sqlite') do + N.times do + File.delete "test.db" rescue nil + SQLite::Database.open( "test.db" ).close + end + end + x.report('sqlite3') do + N.times do + File.delete "test.db" rescue nil + SQLite3::Database.open( "test.db" ).close + end + end +end +File.delete "test.db" rescue nil + +SQLite::Database.open( "test.db" ).close +SQLite3::Database.open( "test3.db" ).close + +puts +puts "database open..." +Benchmark.bm( 7 ) do |x| + x.report('sqlite') do + N.times do + SQLite::Database.open( "test.db" ).close + end + end + x.report('sqlite3') do + N.times do + SQLite3::Database.open( "test3.db" ).close + end + end +end +File.delete "test.db" rescue nil +File.delete "test3.db" rescue nil + +db = SQLite::Database.open( "test.db" ) +db3 = SQLite3::Database.open( "test3.db" ) + +db.execute "create table foo (a,b)" +db3.execute "create table foo (a,b)" + +puts +puts "insertions" +Benchmark.bm( 7 ) do |x| + x.report('sqlite') do + db.transaction do + N.times do |i| + db.execute "insert into foo values (#{i}, #{i+1})" + end + end + end + x.report('sqlite3') do + db3.transaction do + N.times do |i| + db3.execute "insert into foo values (#{i}, #{i+1})" + end + end + end +end + +puts +puts "insertions using prepared statement" +Benchmark.bm( 7 ) do |x| + x.report('sqlite') do + db.transaction do + stmt = db.prepare "insert into foo values (?,?)" + N.times { |i| stmt.execute i, i+1 } + end + end + x.report('sqlite3') do + db3.transaction do + db3.prepare( "insert into foo values (?,?)" ) do |stmt| + N.times { |i| stmt.execute i, i+1 } + end + end + end +end + +db.close +db3.close +File.delete "test.db" rescue nil +File.delete "test3.db" rescue nil + +db = SQLite::Database.open( "test.db" ) +db3 = SQLite3::Database.open( "test3.db" ) + +db.execute "create table foo (a,b)" +db.execute "insert into foo values (1,2)" +db.execute "insert into foo values (3,4)" +db.execute "insert into foo values (5,6)" + +db3.execute "create table foo (a,b)" +db3.execute "insert into foo values (1,2)" +db3.execute "insert into foo values (3,4)" +db3.execute "insert into foo values (5,6)" + +puts +puts "queries" +Benchmark.bm( 7 ) do |x| + x.report('sqlite') do + N.times do + db.execute "select * from foo" + end + end + x.report('sqlite3') do + N.times do + db3.execute "select * from foo" + end + end +end + +db.close +db3.close +File.delete "test.db" rescue nil +File.delete "test3.db" rescue nil diff --git a/vendor/plugins/sqlite3-ruby/test/driver/dl/tc_driver.rb b/vendor/plugins/sqlite3-ruby/test/driver/dl/tc_driver.rb new file mode 100644 index 00000000..b2cb2df4 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/driver/dl/tc_driver.rb @@ -0,0 +1,292 @@ +if (ENV["SQLITE3_DRIVERS"] || "Native").split(/,/).include?("DL") + $:.unshift "../../../lib" + + require 'sqlite3/constants' + require 'sqlite3/driver/dl/driver' + require 'test/unit' + + class TC_DL_Driver < Test::Unit::TestCase + + def utf16ify( str ) + chars = str.split(//) + chars.zip(["\0"] * chars.length).flatten.join + end + + def setup + @driver = SQLite3::Driver::DL::Driver.new + @dbname = "test.db" + @db = nil + end + + def teardown + @driver.close( @db ) rescue nil + File.delete @dbname rescue nil + end + + def test_open + result, @db = @driver.open( @dbname ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + assert File.exist?( @dbname ) + end + + def test_open_utf16 + name = utf16ify( @dbname ) + result, @db = @driver.open( name, true ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + assert File.exist?( @dbname ) + end + + def test_errmsg + result, @db = @driver.open( @dbname ) + msg = @driver.errmsg( @db ) + assert_equal msg, "not an error" + end + + def test_errmsg16 + result, @db = @driver.open( @dbname ) + msg = @driver.errmsg( @db, true ) + assert_equal msg, utf16ify( "not an error" ) + end + + def test_prepare + result, @db = @driver.open( @dbname ) + sql = "create table foo ( a, b )" + result, handle, remainder = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + assert_equal "", remainder + @driver.finalize( handle ) + end + + def test_prepare_error + result, @db = @driver.open( @dbname ) + sql = "create tble foo ( a, b )" + result, handle, remainder = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::ERROR, result + end + + def test_prepare_remainder + result, @db = @driver.open( @dbname ) + sql = "create table foo ( a, b ); select * from foo" + result, handle, remainder = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + assert_equal " select * from foo", remainder + @driver.finalize( handle ) + end + + def test_prepare16 + result, @db = @driver.open( @dbname ) + sql = utf16ify( "create table foo ( a, b )" ) + result, handle, remainder = @driver.prepare( @db, sql, true ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + assert_equal "", remainder + @driver.finalize( handle ) + end + + def test_prepare16_remainder + result, @db = @driver.open( @dbname ) + sql = utf16ify( "create table foo ( a, b ); select * from foo" ) + result, handle, remainder = @driver.prepare( @db, sql, true ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + assert_equal utf16ify( " select * from foo" ), remainder + @driver.finalize( handle ) + end + + def test_complete + assert @driver.complete?( "select * from foo;" ) + end + + def test_complete_fail + assert !@driver.complete?( "select * from foo" ) + end + + def test_complete16 + assert @driver.complete?( utf16ify("select * from foo;"), true ) + end + + def create_foo + result, @db = @driver.open( @dbname ) + sql = "create table foo ( a, b )" + result, handle, = @driver.prepare( @db, sql ) + @driver.step( handle ) + @driver.finalize( handle ) + end + + def populate_foo + create_foo + sql = "insert into foo values ( 100, 200 )" + result, handle, = @driver.prepare( @db, sql ) + @driver.step( handle ) + @driver.finalize( handle ) + end + + def test_step + populate_foo + sql = "select * from foo" + result, handle, = @driver.prepare( @db, sql ) + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::ROW, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::DONE, result + @driver.finalize( handle ) + end + + def test_step_fail + populate_foo + sql = "select * from" + result, handle, = @driver.prepare( @db, sql ) + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::MISUSE, result + @driver.finalize( handle ) + end + + def test_bind_blob + create_foo + sql = "insert into foo (b) values (?)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.bind_blob( handle, 1, "a\0b\1c\2d\0e" ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::DONE, result + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + sql = "select b from foo" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::ROW, result + assert_equal "a\0b\1c\2d\0e", @driver.column_blob( handle, 0 ) + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + end + + def test_bind_double + create_foo + sql = "insert into foo (b) values (?)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.bind_double( handle, 1, 3.14 ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::DONE, result + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + sql = "select b from foo" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::ROW, result + assert_equal 3.14, @driver.column_double( handle, 0 ) + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + end + + def test_bind_int + create_foo + sql = "insert into foo (b) values (?)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.bind_int( handle, 1, 14 ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::DONE, result + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + sql = "select b from foo" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::ROW, result + assert_equal 14, @driver.column_int( handle, 0 ) + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + end + + def test_bind_null + create_foo + sql = "insert into foo (b) values (?)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.bind_null( handle, 1 ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::DONE, result + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + sql = "select b from foo" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::ROW, result + assert_equal SQLite3::Constants::ColumnType::NULL, + @driver.column_type( handle, 0 ) + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + end + + def test_bind_text + create_foo + sql = "insert into foo (b) values (?)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.bind_text( handle, 1, "hello, world" ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::DONE, result + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + sql = "select b from foo" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::ROW, result + assert_equal "hello, world", @driver.column_text( handle, 0 ) + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + end + + def test_bind_text16 + create_foo + sql = "insert into foo (b) values (?)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.bind_text( handle, 1, utf16ify("hello, world"), true ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::DONE, result + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + sql = "select b from foo" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.step( handle ) + assert_equal SQLite3::Constants::ErrorCode::ROW, result + assert_equal "hello, world", @driver.column_text( handle, 0 ) + result = @driver.finalize( handle ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + end + + def test_bind_parameter_index + create_foo + sql = "insert into foo (b) values (:hello)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + result = @driver.bind_parameter_index( handle, ":hello" ) + assert_equal 1, result + result = @driver.bind_parameter_index( handle, ":foo" ) + assert_equal 0, result + @driver.finalize( handle ) + end + + def test_bind_parameter_name + create_foo + sql = "insert into foo (a,b) values (?,:foo)" + result, handle, = @driver.prepare( @db, sql ) + assert_equal SQLite3::Constants::ErrorCode::OK, result + assert_nil nil, @driver.bind_parameter_name(handle,1) + assert_equal ":foo", @driver.bind_parameter_name(handle,2) + @driver.finalize( handle ) + end + + end +end \ No newline at end of file diff --git a/vendor/plugins/sqlite3-ruby/test/mocks.rb b/vendor/plugins/sqlite3-ruby/test/mocks.rb new file mode 100644 index 00000000..f02eed06 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/mocks.rb @@ -0,0 +1,45 @@ +require 'rubygems' +gem 'mocha' + +require 'mocha' + +class Driver < Mocha::Mock + def initialize + super + stubs( :open ).returns([0, 'cookie']) + stubs( :close ).returns(0) + stubs( :complete? ).returns(0) + stubs( :errmsg ).returns('') + stubs( :errcode ).returns(0) + stubs( :trace ).returns(nil) + stubs( :set_authorizer ).returns(0) + stubs( :prepare ).returns([0, 'stmt', 'remainder']) + stubs( :finalize ).returns(0) + stubs( :changes ).returns(14) + stubs( :total_changes ).returns(28) + stubs( :interrupt ).returns(0) + end +end + +class MockResultSet < Mocha::Mock + def initialize + super + stubs( :each ).yields(['foo']) + stubs( :columns ).returns(['name']) + end +end + +class Statement < Mocha::Mock + attr_reader :handle + attr_reader :sql + attr_reader :last_result + + def initialize( handle, sql ) + super() + @handle = handle + @sql = sql + stubs( :close ).returns(0) + stubs( :remainder ).returns('') + stubs( :execute ).returns(MockResultSet.new) + end +end diff --git a/vendor/plugins/sqlite3-ruby/test/native-vs-dl.rb b/vendor/plugins/sqlite3-ruby/test/native-vs-dl.rb new file mode 100644 index 00000000..45e7e28b --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/native-vs-dl.rb @@ -0,0 +1,126 @@ +$:.unshift "../lib", "../ext/sqlite3_api" + +require 'sqlite3' + +require 'benchmark' + +N = 1000 + +$VERBOSE=nil + +puts "database creation..." +Benchmark.bm( 7 ) do |x| + x.report('dl') do + N.times do + File.delete "test.db" rescue nil + SQLite3::Database.open( "test.db", :driver => "DL" ).close + end + end + x.report('native') do + N.times do + File.delete "test.db" rescue nil + SQLite3::Database.open( "test.db", :driver => "Native" ).close + end + end +end +File.delete "test.db" rescue nil + +SQLite3::Database.open( "test.db" ).close + +puts +puts "database open..." +Benchmark.bm( 7 ) do |x| + x.report('dl') do + N.times do + SQLite3::Database.open( "test.db", :driver => "DL" ).close + end + end + x.report('native') do + N.times do + SQLite3::Database.open( "test.db", :driver => "Native" ).close + end + end +end +File.delete "test.db" rescue nil + +dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" ) +native = SQLite3::Database.open( "test-native.db", :driver => "Native" ) + +dl.execute "create table foo (a,b)" +native.execute "create table foo (a,b)" + +puts +puts "insertions" +Benchmark.bm( 7 ) do |x| + x.report('dl') do + dl.transaction do + N.times do |i| + dl.execute "insert into foo values (#{i}, #{i+1})" + end + end + end + x.report('native') do + native.transaction do + N.times do |i| + native.execute "insert into foo values (#{i}, #{i+1})" + end + end + end +end + +puts +puts "insertions using prepared statement" +Benchmark.bm( 7 ) do |x| + x.report('dl') do + dl.transaction do + dl.prepare "insert into foo values (?,?)" do |stmt| + N.times { |i| stmt.execute i, i+1 } + end + end + end + x.report('native') do + native.transaction do + native.prepare( "insert into foo values (?,?)" ) do |stmt| + N.times { |i| stmt.execute i, i+1 } + end + end + end +end + +dl.close +native.close +File.delete "test-dl.db" rescue nil +File.delete "test-native.db" rescue nil + +dl = SQLite3::Database.open( "test-dl.db", :driver => "DL" ) +native = SQLite3::Database.open( "test-native.db", :driver => "Native" ) + +dl.execute "create table foo (a,b)" +dl.execute "insert into foo values (1,2)" +dl.execute "insert into foo values (3,4)" +dl.execute "insert into foo values (5,6)" + +native.execute "create table foo (a,b)" +native.execute "insert into foo values (1,2)" +native.execute "insert into foo values (3,4)" +native.execute "insert into foo values (5,6)" + +puts +puts "queries" +Benchmark.bm( 7 ) do |x| + x.report('dl') do + N.times do + dl.execute "select * from foo" + end + end + x.report('native') do + N.times do + native.execute "select * from foo" + end + end +end + +dl.close +native.close +File.delete "test-dl.db" rescue nil +File.delete "test-native.db" rescue nil diff --git a/vendor/plugins/sqlite3-ruby/test/tc_database.rb b/vendor/plugins/sqlite3-ruby/test/tc_database.rb new file mode 100644 index 00000000..bddee6e5 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/tc_database.rb @@ -0,0 +1,198 @@ +$:.unshift "../lib" + +require 'sqlite3/database' +require 'test/unit' + +require 'mocks' + +class TC_Database_Init < Test::Unit::TestCase + def test_new + # any_instance fails here... + driver = Driver.new + driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie']) + Driver.stubs(:new).returns(driver) + db = SQLite3::Database.new( 'foo.db', :driver => Driver ) + assert !db.closed? + assert !db.results_as_hash + assert !db.type_translation + end + + def test_open + driver = Driver.new + driver.expects(:open).once.with('foo.db', false).returns([0, 'cookie']) + Driver.stubs(:new).returns(driver) + db = SQLite3::Database.open( "foo.db", :driver => Driver ) + assert !db.closed? + assert !db.results_as_hash + assert !db.type_translation + end + + def test_with_type_translation + db = SQLite3::Database.open( "foo.db", :driver => Driver, + :type_translation => true ) + assert db.type_translation + end + + def test_with_results_as_hash + db = SQLite3::Database.open( "foo.db", :driver => Driver, + :results_as_hash => true ) + assert db.results_as_hash + end + + def test_with_type_translation_and_results_as_hash + db = SQLite3::Database.open( "foo.db", :driver => Driver, + :results_as_hash => true, + :type_translation => true ) + assert db.results_as_hash + assert db.type_translation + end +end + +class TC_Database < Test::Unit::TestCase + def setup + @db = SQLite3::Database.open( "foo.db", + :driver => Driver, :statement_factory => Statement ) + end + + def test_quote + assert_equal "''one''two''three''", SQLite3::Database.quote( + "'one'two'three'" ) + end + + def test_complete + Driver.any_instance.expects(:complete?) + @db.complete? "foo" + end + + def test_errmsg + Driver.any_instance.expects(:errmsg) + @db.errmsg + end + + def test_errcode + Driver.any_instance.expects(:errcode) + @db.errcode + end + + def test_translator + translator = @db.translator + assert_instance_of SQLite3::Translator, translator + end + + def test_close + Driver.any_instance.expects(:close).returns(0) + @db.close + assert @db.closed? + Driver.any_instance.expects(:close).never + @db.close + end + + def test_trace + Driver.any_instance.expects(:trace).with('cookie', 15) + @db.trace( 15 ) { "foo" } + # assert_equal 1, driver.mock_blocks[:trace].length + end + + def test_authorizer + Driver.any_instance.expects(:set_authorizer).with('cookie', 15).returns(0) + @db.authorizer( 15 ) { "foo" } + # assert_equal 1, driver.mock_blocks[:set_authorizer].length + end + + def test_prepare_no_block + Statement.any_instance.expects(:close).never + assert_nothing_raised { @db.prepare( "foo" ) } + end + + def test_prepare_with_block + called = false + # any_instance fails here... + statement = Statement.new('cookie', 'foo') + statement.expects(:close).once + Statement.stubs(:new).returns(statement) + @db.prepare( "foo" ) { |stmt| called = true } + assert called + end + + def test_execute_no_block + # any_instance fails here... + statement = Statement.new('cookie', 'foo') + statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new) + Statement.stubs(:new).returns(statement) + MockResultSet.any_instance.stubs(:inject).returns([['foo']]) + result = @db.execute( "foo", "bar", "baz" ) + assert_equal [["foo"]], result + end + + def test_execute_with_block + called = false + # any_instance fails here... + statement = Statement.new('cookie', 'foo') + statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new) + Statement.stubs(:new).returns(statement) + @db.execute( "foo", "bar", "baz" ) do |row| + called = true + assert_equal ["foo"], row + end + + assert called + end + + def test_execute2_no_block + # any_instance fails here... + statement = Statement.new('cookie', 'foo') + statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new) + Statement.stubs(:new).returns(statement) + MockResultSet.any_instance.stubs(:inject).returns([['name'], ['foo']]) + result = @db.execute2( "foo", "bar", "baz" ) + assert_equal [["name"],["foo"]], result + end + + def test_execute2_with_block + called = false + parts = [ ["name"],["foo"] ] + # any_instance fails here... + statement = Statement.new('cookie', 'foo') + statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new) + Statement.stubs(:new).returns(statement) + @db.execute2( "foo", "bar", "baz" ) do |row| + called = true + assert_equal parts.shift, row + end + + assert called + end + + def test_execute_batch + # any_instance fails here... + statement = Statement.new('cookie', 'foo') + statement.expects(:execute).with('bar', 'baz').returns(MockResultSet.new) + Statement.stubs(:new).returns(statement) + @db.execute_batch( "foo", "bar", "baz" ) + end + + def test_get_first_row + result = @db.get_first_row( "foo", "bar", "baz" ) + assert_equal ["foo"], result + end + + def test_get_first_value + result = @db.get_first_value( "foo", "bar", "baz" ) + assert_equal "foo", result + end + + def test_changes + Driver.any_instance.expects(:changes).returns(14) + assert_equal 14, @db.changes + end + + def test_total_changes + Driver.any_instance.expects(:total_changes).returns(28) + assert_equal 28, @db.total_changes + end + + def test_interrupt + Driver.any_instance.expects(:interrupt) + @db.interrupt + end +end diff --git a/vendor/plugins/sqlite3-ruby/test/tc_errors.rb b/vendor/plugins/sqlite3-ruby/test/tc_errors.rb new file mode 100644 index 00000000..cec552fd --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/tc_errors.rb @@ -0,0 +1,21 @@ +$:.unshift "../lib" + +require 'sqlite3/errors' +require 'test/unit' +require 'mocha' + +class TC_Errors < Test::Unit::TestCase + (1..26).each do |code| + define_method( "test_error_code_%02d" % code ) do + db = stub('database', :errmsg => 'message') + begin + SQLite3::Error.check( code, db ) + rescue SQLite3::Exception => e + assert_instance_of SQLite3::EXCEPTIONS[code], e + assert_equal code, e.code + assert_equal code, e.class.code + assert_equal "message", e.message + end + end + end +end diff --git a/vendor/plugins/sqlite3-ruby/test/tc_integration.rb b/vendor/plugins/sqlite3-ruby/test/tc_integration.rb new file mode 100644 index 00000000..515c7114 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/tc_integration.rb @@ -0,0 +1,1044 @@ +$:.unshift "#{File.dirname(__FILE__)}/../lib" +$:.unshift "#{File.dirname(__FILE__)}/../ext/sqlite3_api" + +require 'test/unit' +require 'benchmark' +require 'sqlite3/database' +require 'thread' + +class String + def to_utf16(terminate=false) + self.split(//).map { |c| c[0] }.pack("v*") + + (terminate ? "\0\0" : "") + end + + def from_utf16 + result = "" + length.times do |i| + result << self[i,1] if i % 2 == 0 && self[i] != 0 + end + result + end +end + +module Integration + + drivers_to_test = ( ENV["SQLITE3_DRIVERS"] || "Native" ).split(',') + drivers_to_test.each do |driver| + + # == TC_OpenClose ========================================================= + + test_case = Class.new( Test::Unit::TestCase ) do + define_method( "test_create_close" ) do + begin + db = SQLite3::Database.new( "test-create.db", + :driver => driver ) + assert File.exist?( "test-create.db" ) + assert_nothing_raised { db.close } + ensure + File.delete( "test-create.db" ) rescue nil + end + end + + define_method( "test_open_close" ) do + begin + File.open( "test-open.db", "w" ) { |f| } + assert File.exist?( "test-open.db" ) + db = SQLite3::Database.new( "test-open.db", + :driver => driver ) + assert_nothing_raised { db.close } + ensure + File.delete( "test-open.db" ) rescue nil + end + end + + define_method( "test_bad_open" ) do + assert_raise( SQLite3::CantOpenException ) do + SQLite3::Database.new( ".", :driver => driver ) + end + end + end + const_set( "TC_OpenClose_#{driver}", test_case ) + + # == TC_Database ========================================================== + + test_case = Class.new( Test::Unit::TestCase ) do + define_method( "setup" ) do + @db = SQLite3::Database.new( "test.db", :driver=>driver ) + @db.transaction do + @db.execute "create table foo ( a integer primary key, b text )" + @db.execute "insert into foo ( b ) values ( 'foo' )" + @db.execute "insert into foo ( b ) values ( 'bar' )" + @db.execute "insert into foo ( b ) values ( 'baz' )" + end + end + + define_method( "teardown" ) do + @db.close + File.delete( "test.db" ) + end + + define_method( "test_table_info_with_type_translation_active" ) do + @db.type_translation = true + assert_nothing_raised { @db.table_info("foo") } + end + + define_method( "test_table_info_with_defaults_for_version_3_3_8_and_higher" ) do + @db.transaction do + @db.execute "create table defaults_test ( a string default NULL, b string default 'Hello' )" + data = @db.table_info( "defaults_test" ) + assert_equal({"name" => "a", "type" => "string", "dflt_value" => nil, "notnull" => "0", "cid" => "0", "pk" => "0"}, + data[0]) + assert_equal({"name" => "b", "type" => "string", "dflt_value" => "Hello", "notnull" => "0", "cid" => "1", "pk" => "0"}, + data[1]) + end + end + + define_method( "test_table_info_without_defaults_for_version_3_3_8_and_higher" ) do + @db.transaction do + @db.execute "create table no_defaults_test ( a integer default 1, b integer )" + data = @db.table_info( "no_defaults_test" ) + assert_equal({"name" => "a", "type" => "integer", "dflt_value" => "1", "notnull" => "0", "cid" => "0", "pk" => "0"}, + data[0]) + assert_equal({"name" => "b", "type" => "integer", "dflt_value" => nil, "notnull" => "0", "cid" => "1", "pk" => "0"}, + data[1]) + end + end + + define_method( "test_complete_fail" ) do + assert !@db.complete?( "select * from foo" ) + end + define_method( "test_complete_success" ) do + assert @db.complete?( "select * from foo;" ) + end + + define_method( "test_complete_fail_utf16" ) do + assert !@db.complete?( "select * from foo".to_utf16(false), true ) + end + + define_method( "test_complete_success_utf16" ) do + assert @db.complete?( "select * from foo;".to_utf16(true), true ) + end + + define_method( "test_errmsg" ) do + assert_equal "not an error", @db.errmsg + end + + define_method( "test_errmsg_utf16" ) do + assert_equal "not an error".to_utf16, @db.errmsg(true) + end + + define_method( "test_errcode" ) do + assert_equal 0, @db.errcode + end + + define_method( "test_trace" ) do + result = nil + @db.trace( "data" ) { |data,sql| result = [ data, sql ]; 0 } + @db.execute "select * from foo" + assert_equal ["data","select * from foo"], result + end + + define_method( "test_authorizer_okay" ) do + @db.authorizer( "data" ) { |data,type,a,b,c,d| 0 } + rows = @db.execute "select * from foo" + assert_equal 3, rows.length + end + + define_method( "test_authorizer_error" ) do + @db.authorizer( "data" ) { |data,type,a,b,c,d| 1 } + assert_raise( SQLite3::AuthorizationException ) do + @db.execute "select * from foo" + end + end + +# FIXME: this test is failing with sqlite3 3.2.5 +# define_method( "test_authorizer_silent" ) do +# @db.authorizer( "data" ) { |data,type,a,b,c,d| 2 } +# rows = @db.execute "select * from foo" +# assert rows.empty? +# end + + define_method( "test_prepare_invalid_syntax" ) do + assert_raise( SQLite3::SQLException ) do + @db.prepare "select from foo" + end + end + + define_method( "test_prepare_invalid_column" ) do + assert_raise( SQLite3::SQLException ) do + @db.prepare "select k from foo" + end + end + + define_method( "test_prepare_invalid_table" ) do + assert_raise( SQLite3::SQLException ) do + @db.prepare "select * from barf" + end + end + + define_method( "test_prepare_no_block" ) do + stmt = @db.prepare "select * from foo" + assert stmt.respond_to?(:execute) + stmt.close + end + + define_method( "test_prepare_with_block" ) do + called = false + @db.prepare "select * from foo" do |stmt| + called = true + assert stmt.respond_to?(:execute) + end + assert called + end + + define_method( "test_execute_no_block_no_bind_no_match" ) do + rows = @db.execute( "select * from foo where a > 100" ) + assert rows.empty? + end + + define_method( "test_execute_with_block_no_bind_no_match" ) do + called = false + @db.execute( "select * from foo where a > 100" ) do |row| + called = true + end + assert !called + end + + define_method( "test_execute_no_block_with_bind_no_match" ) do + rows = @db.execute( "select * from foo where a > ?", 100 ) + assert rows.empty? + end + + define_method( "test_execute_with_block_with_bind_no_match" ) do + called = false + @db.execute( "select * from foo where a > ?", 100 ) do |row| + called = true + end + assert !called + end + + define_method( "test_execute_no_block_no_bind_with_match" ) do + rows = @db.execute( "select * from foo where a = 1" ) + assert_equal 1, rows.length + end + + define_method( "test_execute_with_block_no_bind_with_match" ) do + called = 0 + @db.execute( "select * from foo where a = 1" ) do |row| + called += 1 + end + assert_equal 1, called + end + + define_method( "test_execute_no_block_with_bind_with_match" ) do + rows = @db.execute( "select * from foo where a = ?", 1 ) + assert_equal 1, rows.length + end + + define_method( "test_execute_with_block_with_bind_with_match" ) do + called = 0 + @db.execute( "select * from foo where a = ?", 1 ) do |row| + called += 1 + end + assert_equal 1, called + end + + define_method( "test_execute2_no_block_no_bind_no_match" ) do + columns, *rows = @db.execute2( "select * from foo where a > 100" ) + assert rows.empty? + assert [ "a", "b" ], columns + end + + define_method( "test_execute2_with_block_no_bind_no_match" ) do + called = 0 + @db.execute2( "select * from foo where a > 100" ) do |row| + assert [ "a", "b" ], row unless called == 0 + called += 1 + end + assert_equal 1, called + end + + define_method( "test_execute2_no_block_with_bind_no_match" ) do + columns, *rows = @db.execute2( "select * from foo where a > ?", 100 ) + assert rows.empty? + assert [ "a", "b" ], columns + end + + define_method( "test_execute2_with_block_with_bind_no_match" ) do + called = 0 + @db.execute2( "select * from foo where a > ?", 100 ) do |row| + assert [ "a", "b" ], row unless called == 0 + called += 1 + end + assert_equal 1, called + end + + define_method( "test_execute2_no_block_no_bind_with_match" ) do + columns, *rows = @db.execute2( "select * from foo where a = 1" ) + assert_equal 1, rows.length + assert [ "a", "b" ], columns + end + + define_method( "test_execute2_with_block_no_bind_with_match" ) do + called = 0 + @db.execute2( "select * from foo where a = 1" ) do |row| + assert [ "a", "b" ], row unless called == 0 + called += 1 + end + assert_equal 2, called + end + + define_method( "test_execute2_no_block_with_bind_with_match" ) do + columns, *rows = @db.execute2( "select * from foo where a = ?", 1 ) + assert_equal 1, rows.length + assert [ "a", "b" ], columns + end + + define_method( "test_execute2_with_block_with_bind_with_match" ) do + called = 0 + @db.execute2( "select * from foo where a = ?", 1 ) do |row| + called += 1 + end + assert_equal 2, called + end + + define_method( "test_execute_batch_empty" ) do + assert_nothing_raised { @db.execute_batch "" } + end + + define_method( "test_execute_batch_no_bind" ) do + @db.transaction do + @db.execute_batch <<-SQL + create table bar ( a, b, c ); + insert into bar values ( 'one', 2, 'three' ); + insert into bar values ( 'four', 5, 'six' ); + insert into bar values ( 'seven', 8, 'nine' ); + SQL + end + rows = @db.execute( "select * from bar" ) + assert_equal 3, rows.length + end + + define_method( "test_execute_batch_with_bind" ) do + @db.execute_batch( <<-SQL, 1 ) + create table bar ( a, b, c ); + insert into bar values ( 'one', 2, ? ); + insert into bar values ( 'four', 5, ? ); + insert into bar values ( 'seven', 8, ? ); + SQL + rows = @db.execute( "select * from bar" ).map { |a,b,c| c } + assert_equal %w{1 1 1}, rows + end + + define_method( "test_query_no_block_no_bind_no_match" ) do + result = @db.query( "select * from foo where a > 100" ) + assert_nil result.next + result.close + end + + define_method( "test_query_with_block_no_bind_no_match" ) do + r = nil + @db.query( "select * from foo where a > 100" ) do |result| + assert_nil result.next + r = result + end + assert r.closed? + end + + define_method( "test_query_no_block_with_bind_no_match" ) do + result = @db.query( "select * from foo where a > ?", 100 ) + assert_nil result.next + result.close + end + + define_method( "test_query_with_block_with_bind_no_match" ) do + r = nil + @db.query( "select * from foo where a > ?", 100 ) do |result| + assert_nil result.next + r = result + end + assert r.closed? + end + + define_method( "test_query_no_block_no_bind_with_match" ) do + result = @db.query( "select * from foo where a = 1" ) + assert_not_nil result.next + assert_nil result.next + result.close + end + + define_method( "test_query_with_block_no_bind_with_match" ) do + r = nil + @db.query( "select * from foo where a = 1" ) do |result| + assert_not_nil result.next + assert_nil result.next + r = result + end + assert r.closed? + end + + define_method( "test_query_no_block_with_bind_with_match" ) do + result = @db.query( "select * from foo where a = ?", 1 ) + assert_not_nil result.next + assert_nil result.next + result.close + end + + define_method( "test_query_with_block_with_bind_with_match" ) do + r = nil + @db.query( "select * from foo where a = ?", 1 ) do |result| + assert_not_nil result.next + assert_nil result.next + r = result + end + assert r.closed? + end + + define_method( "test_get_first_row_no_bind_no_match" ) do + result = @db.get_first_row( "select * from foo where a=100" ) + assert_nil result + end + + define_method( "test_get_first_row_no_bind_with_match" ) do + result = @db.get_first_row( "select * from foo where a=1" ) + assert_equal [ "1", "foo" ], result + end + + define_method( "test_get_first_row_with_bind_no_match" ) do + result = @db.get_first_row( "select * from foo where a=?", 100 ) + assert_nil result + end + + define_method( "test_get_first_row_with_bind_with_match" ) do + result = @db.get_first_row( "select * from foo where a=?", 1 ) + assert_equal [ "1", "foo" ], result + end + + define_method( "test_get_first_value_no_bind_no_match" ) do + result = @db.get_first_value( "select b, a from foo where a=100" ) + assert_nil result + end + + define_method( "test_get_first_value_no_bind_with_match" ) do + result = @db.get_first_value( "select b, a from foo where a=1" ) + assert_equal "foo", result + end + + define_method( "test_get_first_value_with_bind_no_match" ) do + result = @db.get_first_value( "select b, a from foo where a=?", 100 ) + assert_nil result + end + + define_method( "test_get_first_value_with_bind_with_match" ) do + result = @db.get_first_value( "select b, a from foo where a=?", 1 ) + assert_equal "foo", result + end + + define_method( "test_last_insert_row_id" ) do + @db.execute "insert into foo ( b ) values ( 'test' )" + assert_equal 4, @db.last_insert_row_id + @db.execute "insert into foo ( b ) values ( 'again' )" + assert_equal 5, @db.last_insert_row_id + end + + define_method( "test_changes" ) do + @db.execute "insert into foo ( b ) values ( 'test' )" + assert_equal 1, @db.changes + @db.execute "delete from foo where 1=1" + assert_equal 4, @db.changes + end + + define_method( "test_total_changes" ) do + assert_equal 3, @db.total_changes + @db.execute "insert into foo ( b ) values ( 'test' )" + @db.execute "delete from foo where 1=1" + assert_equal 8, @db.total_changes + end + + define_method( "test_transaction_nest" ) do + assert_raise( SQLite3::SQLException ) do + @db.transaction do + @db.transaction do + end + end + end + end + + define_method( "test_transaction_rollback" ) do + @db.transaction + @db.execute_batch <<-SQL + insert into foo (b) values ( 'test1' ); + insert into foo (b) values ( 'test2' ); + insert into foo (b) values ( 'test3' ); + insert into foo (b) values ( 'test4' ); + SQL + assert_equal 7, @db.get_first_value("select count(*) from foo").to_i + @db.rollback + assert_equal 3, @db.get_first_value("select count(*) from foo").to_i + end + + define_method( "test_transaction_commit" ) do + @db.transaction + @db.execute_batch <<-SQL + insert into foo (b) values ( 'test1' ); + insert into foo (b) values ( 'test2' ); + insert into foo (b) values ( 'test3' ); + insert into foo (b) values ( 'test4' ); + SQL + assert_equal 7, @db.get_first_value("select count(*) from foo").to_i + @db.commit + assert_equal 7, @db.get_first_value("select count(*) from foo").to_i + end + + define_method( "test_transaction_rollback_in_block" ) do + assert_raise( SQLite3::SQLException ) do + @db.transaction do + @db.rollback + end + end + end + + define_method( "test_transaction_commit_in_block" ) do + assert_raise( SQLite3::SQLException ) do + @db.transaction do + @db.commit + end + end + end + + define_method( "test_transaction_active" ) do + assert !@db.transaction_active? + @db.transaction + assert @db.transaction_active? + @db.commit + assert !@db.transaction_active? + end + + define_method( "no_tests_at" ) do |file,line,method| + warn "[(#{self.class}):#{file}:#{line}] no tests for #{method}" + end + + define_method( "test_interrupt" ) do + @db.create_function( "abort", 1 ) do |func,x| + @db.interrupt + func.result = x + end + + assert_raise( SQLite3::SQLException ) do + @db.execute "select abort(a) from foo" + end + end + + define_method( "test_busy_handler_outwait" ) do + busy = Mutex.new + busy.lock + handler_call_count = 0 + + t = Thread.new do + begin + db2 = SQLite3::Database.open( "test.db", :driver=>driver ) + db2.transaction( :exclusive ) do + busy.lock + end + ensure + db2.close if db2 + end + end + + @db.busy_handler do |data,count| + handler_call_count += 1 + busy.unlock + true + end + + assert_nothing_raised do + @db.execute "insert into foo (b) values ( 'from 2' )" + end + + t.join + + assert_equal 1, handler_call_count + end + + define_method( "test_busy_handler_impatient" ) do + busy = Mutex.new + busy.lock + handler_call_count = 0 + + t = Thread.new do + begin + db2 = SQLite3::Database.open( "test.db", :driver=>driver ) + db2.transaction( :exclusive ) do + busy.lock + end + ensure + db2.close if db2 + end + end + + @db.busy_handler do |data, count| + handler_call_count += 1 + false + end + + assert_raise( SQLite3::BusyException ) do + @db.execute "insert into foo (b) values ( 'from 2' )" + end + + busy.unlock + t.join + + assert_equal 1, handler_call_count + end + + define_method( "test_busy_timeout" ) do + @db.busy_timeout 1000 + busy = Mutex.new + busy.lock + + t = Thread.new do + begin + db2 = SQLite3::Database.open( "test.db", :driver=>driver ) + db2.transaction( :exclusive ) do + busy.lock + end + ensure + db2.close if db2 + end + end + + time = Benchmark.measure do + assert_raise( SQLite3::BusyException ) do + @db.execute "insert into foo (b) values ( 'from 2' )" + end + end + + busy.unlock + t.join + + assert time.real*1000 >= 1000 + end + + define_method( "test_create_function" ) do + @db.create_function( "munge", 1 ) do |func,x| + func.result = ">>>#{x}<<<" + end + + value = @db.get_first_value( "select munge(b) from foo where a=1" ) + assert_match( />>>.*<<driver ) + @db.transaction do + @db.execute "create table foo ( a integer primary key, b text )" + @db.execute "insert into foo ( b ) values ( 'foo' )" + @db.execute "insert into foo ( b ) values ( 'bar' )" + @db.execute "insert into foo ( b ) values ( 'baz' )" + end + @stmt = @db.prepare( "select * from foo where a in ( ?, :named )" ) + end + + define_method( "teardown" ) do + @stmt.close + @db.close + File.delete( "test.db" ) + end + + define_method( "test_remainder_empty" ) do + assert_equal "", @stmt.remainder + end + + define_method( "test_remainder_nonempty" ) do + called = false + @db.prepare( "select * from foo;\n blah" ) do |stmt| + called = true + assert_equal "\n blah", stmt.remainder + end + assert called + end + + define_method( "test_bind_params_empty" ) do + assert_nothing_raised { @stmt.bind_params } + assert @stmt.execute!.empty? + end + + define_method( "test_bind_params_array" ) do + @stmt.bind_params 1, 2 + assert_equal 2, @stmt.execute!.length + end + + define_method( "test_bind_params_hash" ) do + @stmt.bind_params ":named" => 2 + assert_equal 1, @stmt.execute!.length + end + + define_method( "test_bind_params_hash_without_colon" ) do + @stmt.bind_params "named" => 2 + assert_equal 1, @stmt.execute!.length + end + + define_method( "test_bind_params_hash_as_symbol" ) do + @stmt.bind_params :named => 2 + assert_equal 1, @stmt.execute!.length + end + + define_method( "test_bind_params_mixed" ) do + @stmt.bind_params( 1, ":named" => 2 ) + assert_equal 2, @stmt.execute!.length + end + + define_method( "test_bind_param_by_index" ) do + @stmt.bind_params( 1, 2 ) + assert_equal 2, @stmt.execute!.length + end + + define_method( "test_bind_param_by_name_bad" ) do + assert_raise( SQLite3::Exception ) { @stmt.bind_param( "@named", 2 ) } + end + + define_method( "test_bind_param_by_name_good" ) do + @stmt.bind_param( ":named", 2 ) + assert_equal 1, @stmt.execute!.length + end + + define_method( "test_bind_param_with_various_types" ) do + @db.transaction do + @db.execute "create table all_types ( a integer primary key, b float, c string, d integer )" + @db.execute "insert into all_types ( b, c, d ) values ( 1.4, 'hello', 68719476735 )" + end + + assert_equal 1, @db.execute( "select * from all_types where b = ?", 1.4 ).length + assert_equal 1, @db.execute( "select * from all_types where c = ?", 'hello').length + assert_equal 1, @db.execute( "select * from all_types where d = ?", 68719476735).length + end + + define_method( "test_execute_no_bind_no_block" ) do + assert_instance_of SQLite3::ResultSet, @stmt.execute + end + + define_method( "test_execute_with_bind_no_block" ) do + assert_instance_of SQLite3::ResultSet, @stmt.execute( 1, 2 ) + end + + define_method( "test_execute_no_bind_with_block" ) do + called = false + @stmt.execute { |row| called = true } + assert called + end + + define_method( "test_execute_with_bind_with_block" ) do + called = 0 + @stmt.execute( 1, 2 ) { |row| called += 1 } + assert_equal 1, called + end + + define_method( "test_reexecute" ) do + r = @stmt.execute( 1, 2 ) + assert_equal 2, r.to_a.length + assert_nothing_raised { r = @stmt.execute( 1, 2 ) } + assert_equal 2, r.to_a.length + end + + define_method( "test_execute_bang_no_bind_no_block" ) do + assert @stmt.execute!.empty? + end + + define_method( "test_execute_bang_with_bind_no_block" ) do + assert_equal 2, @stmt.execute!( 1, 2 ).length + end + + define_method( "test_execute_bang_no_bind_with_block" ) do + called = 0 + @stmt.execute! { |row| called += 1 } + assert_equal 0, called + end + + define_method( "test_execute_bang_with_bind_with_block" ) do + called = 0 + @stmt.execute!( 1, 2 ) { |row| called += 1 } + assert_equal 2, called + end + + define_method( "test_columns" ) do + c1 = @stmt.columns + c2 = @stmt.columns + assert_same c1, c2 + assert_equal 2, c1.length + end + + define_method( "test_columns_computed" ) do + called = false + @db.prepare( "select count(*) from foo" ) do |stmt| + called = true + assert_equal [ "count(*)" ], stmt.columns + end + assert called + end + + define_method( "test_types" ) do + t1 = @stmt.types + t2 = @stmt.types + assert_same t1, t2 + assert_equal 2, t1.length + end + + define_method( "test_types_computed" ) do + called = false + @db.prepare( "select count(*) from foo" ) do |stmt| + called = true + assert_equal [ nil ], stmt.types + end + assert called + end + + define_method( "test_close" ) do + stmt = @db.prepare( "select * from foo" ) + assert !stmt.closed? + stmt.close + assert stmt.closed? + assert_raise( SQLite3::Exception ) { stmt.execute } + assert_raise( SQLite3::Exception ) { stmt.execute! } + assert_raise( SQLite3::Exception ) { stmt.close } + assert_raise( SQLite3::Exception ) { stmt.bind_params 5 } + assert_raise( SQLite3::Exception ) { stmt.bind_param 1, 5 } + assert_raise( SQLite3::Exception ) { stmt.columns } + assert_raise( SQLite3::Exception ) { stmt.types } + end + + define_method( "test_committing_tx_with_statement_active" ) do + called = false + @db.prepare( "select count(*) from foo" ) do |stmt| + called = true + count = stmt.execute!.first.first.to_i + @db.transaction do + @db.execute "insert into foo ( b ) values ( 'hello' )" + end + new_count = stmt.execute!.first.first.to_i + assert_equal new_count, count+1 + end + assert called + end + end + const_set( "TC_Statement_#{driver}", test_case ) + + # == TC_ResultSet ========================================================= + + test_case = Class.new( Test::Unit::TestCase ) do + define_method( "setup" ) do + @db = SQLite3::Database.new( "test.db", :driver=>driver ) + @db.transaction do + @db.execute "create table foo ( a integer primary key, b text )" + @db.execute "insert into foo ( b ) values ( 'foo' )" + @db.execute "insert into foo ( b ) values ( 'bar' )" + @db.execute "insert into foo ( b ) values ( 'baz' )" + end + @stmt = @db.prepare( "select * from foo where a in ( ?, ? )" ) + @result = @stmt.execute + end + + define_method( "teardown" ) do + @stmt.close + @db.close + File.delete( "test.db" ) + end + + define_method( "test_reset_unused" ) do + assert_nothing_raised { @result.reset } + assert @result.to_a.empty? + end + + define_method( "test_reset_used" ) do + @result.to_a + assert_nothing_raised { @result.reset } + assert @result.to_a.empty? + end + + define_method( "test_reset_with_bind" ) do + @result.to_a + assert_nothing_raised { @result.reset( 1, 2 ) } + assert_equal 2, @result.to_a.length + end + + define_method( "test_eof_inner" ) do + @result.reset( 1 ) + assert !@result.eof? + end + + define_method( "test_eof_edge" ) do + @result.reset( 1 ) + @result.next # to first row + @result.next # to end of result set + assert @result.eof? + end + + define_method( "test_next_eof" ) do + @result.reset( 1 ) + assert_not_nil @result.next + assert_nil @result.next + end + + define_method( "test_next_no_type_translation_no_hash" ) do + @result.reset( 1 ) + assert_equal [ "1", "foo" ], @result.next + end + + define_method( "test_next_type_translation" ) do + @db.type_translation = true + @result.reset( 1 ) + assert_equal [ 1, "foo" ], @result.next + end + + define_method( "test_next_type_translation_with_untyped_column" ) do + @db.type_translation = true + @db.query( "select count(*) from foo" ) do |result| + assert_equal ["3"], result.next + end + end + + define_method( "test_type_translation_with_null_column" ) do + @db.type_translation = true + @db.execute "create table bar ( a integer, b time, c string )" + @db.execute "insert into bar (a, b, c) values (NULL, '1974-07-25 14:39:00', 'hello')" + @db.execute "insert into bar (a, b, c) values (1, NULL, 'hello')" + @db.execute "insert into bar (a, b, c) values (2, '1974-07-25 14:39:00', NULL)" + @db.query( "select * from bar" ) do |result| + assert_equal [nil, Time.local(1974, 7, 25, 14, 39, 0), 'hello'], result.next + assert_equal [1, nil, 'hello'], result.next + assert_equal [2, Time.local(1974, 7, 25, 14, 39, 0), nil], result.next + end + end + + define_method( "test_date_and_time_translation" ) do + @db.type_translation = true + @db.execute "create table bar ( a date, b datetime, c time, d timestamp )" + @db.execute "insert into bar (a, b, c, d) values ('1999-01-08', '1997-12-17 07:37:16', '07:37:16', '2004-10-19 10:23:54')" + @db.query( "select * from bar" ) do |result| + result = result.next + assert result[0].is_a?(Date) + assert result[1].is_a?(DateTime) + assert result[2].is_a?(Time) + assert result[3].is_a?(Time) + end + end + + define_method( "test_next_results_as_hash" ) do + @db.results_as_hash = true + @result.reset( 1 ) + assert_equal( { "a" => "1", "b" => "foo", 0 => "1", 1 => "foo" }, + @result.next ) + end + + define_method( "test_each" ) do + called = 0 + @result.reset( 1, 2 ) + @result.each { |row| called += 1 } + assert_equal 2, called + end + + define_method( "test_enumerable" ) do + @result.reset( 1, 2 ) + assert_equal 2, @result.to_a.length + end + + define_method( "test_types" ) do + assert_equal [ "integer", "text" ], @result.types + end + + define_method( "test_columns" ) do + assert_equal [ "a", "b" ], @result.columns + end + + define_method( "test_close" ) do + stmt = @db.prepare( "select * from foo" ) + result = stmt.execute + assert !result.closed? + result.close + assert result.closed? + assert stmt.closed? + assert_raise( SQLite3::Exception ) { result.reset } + assert_raise( SQLite3::Exception ) { result.next } + assert_raise( SQLite3::Exception ) { result.each } + assert_raise( SQLite3::Exception ) { result.close } + assert_raise( SQLite3::Exception ) { result.types } + assert_raise( SQLite3::Exception ) { result.columns } + end + end + const_set( "TC_ResultSet_#{driver}", test_case ) + end + +end diff --git a/vendor/plugins/sqlite3-ruby/test/tests.rb b/vendor/plugins/sqlite3-ruby/test/tests.rb new file mode 100644 index 00000000..cf24d271 --- /dev/null +++ b/vendor/plugins/sqlite3-ruby/test/tests.rb @@ -0,0 +1,6 @@ +Dir.chdir File.dirname( __FILE__ ) +$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib" +$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../ext/sqlite3_api" +p $LOAD_PATH + +Dir["**/tc_*.rb"].each { |file| load file }