ydbi 0.5.8 → 0.6.0

data/test/dbd/sqlite3/test_database.rb

@@ -0,0 +1,77 @@
+class TestDatabase < DBDConfig.testbase(:sqlite3)
+    def test_database_name
+        assert_nothing_raised do
+            assert_equal DBDConfig.get_config[dbtype]['dbname'], @dbh.database_name
+        end
+    end
+
+    def test_disconnect
+        assert_nil @dbh.disconnect
+        assert_nil @dbh.instance_variable_get("@db")
+    end
+
+    def test_columns
+        assert_equal [
+            {
+                :name      => "name",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 100,
+                :precision => 255,
+                :type_name => "varchar"
+            },
+            {
+                :name      => "age",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 4,
+                :type_name => "integer"
+            }
+        ], @dbh.columns("names")
+
+        assert_equal [
+            {
+                :name      => "name",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 100,
+                :precision => 255,
+                :type_name => "varchar"
+            },
+            {
+                :name      => "age",
+                :default   => nil,
+                :nullable  => true,
+                :sql_type  => 4,
+                :type_name => "integer"
+            }
+        ], @dbh.columns("names_defined_with_spaces")
+    end
+    
+    def test_parse_type
+      # Some tests to ensure various whitespace and case styles don't confuse parse_type.
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR(4096)' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'varchar(4096)' )
+      assert_equal 'varchar', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR( 4096 )' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR ( 4096 )' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+      
+      match = DBI::DBD::SQLite3.parse_type( 'VARCHAR (4096)' )
+      assert_equal 'VARCHAR', match[ 1 ]
+      assert_equal '4096', match[ 3 ]
+    end
+end

data/test/dbd/sqlite3/test_driver.rb

@@ -0,0 +1,67 @@
+class TestDriver < DBDConfig.testbase(:sqlite3)
+    def test_require
+        require 'dbd/SQLite3'
+        assert_kind_of Module, DBI
+        assert_kind_of Module, DBI::DBD
+        assert_kind_of Module, DBI::DBD::SQLite3
+        assert_kind_of Class, DBI::DBD::SQLite3::Driver
+        assert_kind_of Class, DBI::DBD::SQLite3::Database
+        assert_kind_of Class, DBI::DBD::SQLite3::Statement
+    end
+
+    def test_connect
+        config = DBDConfig.get_config['sqlite3']
+
+        # this tests DBI more than SQLite, but makes sure our chain works with it.
+        dbh = DBI.connect("dbi:SQLite3:" + config['dbname'], nil, nil, {})
+        assert dbh
+        assert_kind_of DBI::DatabaseHandle, dbh
+
+        # first argument should be a string
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect(nil, nil, nil, { })
+        end
+
+        # that string should have some frackin' length
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect("", nil, nil, { })
+        end
+
+        # last argument should be a hash
+        assert_raises(DBI::InterfaceError) do
+            DBI::DBD::SQLite3::Driver.new.connect(config['dbname'], nil, nil, nil)
+        end
+
+        dbh = nil
+        driver = nil
+        assert_nothing_raised do
+            driver = DBI::DBD::SQLite3::Driver.new
+            dbh = driver.connect(config['dbname'], nil, nil, { })
+        end
+
+        assert_kind_of DBI::DBD::SQLite3::Driver, driver
+        assert_kind_of DBI::DBD::SQLite3::Database, dbh
+
+        assert !dbh.instance_variable_get("@autocommit")
+
+        dbh = nil 
+        driver = nil
+        assert_nothing_raised do
+            dbh = DBI::DBD::SQLite3::Driver.new.connect(config['dbname'], nil, nil, { "AutoCommit" => true, "sqlite_full_column_names" => true })
+        end
+       
+        assert dbh
+        assert dbh.instance_variable_get("@attr")
+        assert_kind_of SQLite3::Database, dbh.instance_variable_get("@db")
+
+        assert File.exist?(config['dbname'])
+    end
+
+    def setup
+    end
+
+    def teardown
+        config = DBDConfig.get_config['sqlite3']
+        FileUtils.rm_f(config['dbname'])
+    end
+end

data/test/dbd/sqlite3/test_statement.rb

@@ -0,0 +1,88 @@
+class TestStatement < DBDConfig.testbase(:sqlite3)
+    def test_constructor
+        sth = DBI::DBD::SQLite3::Statement.new("select * from names", @dbh.instance_variable_get("@handle").instance_variable_get("@db"))
+
+        assert_kind_of DBI::DBD::SQLite3::Statement, sth
+        assert sth.instance_variable_get("@db")
+        assert_kind_of ::SQLite3::Database, sth.instance_variable_get("@db")
+        assert_equal(@dbh.instance_variable_get("@handle").instance_variable_get("@db"), sth.instance_variable_get("@db"))
+        assert_kind_of ::SQLite3::Statement, sth.instance_variable_get("@stmt")
+        assert_nil(@sth.instance_variable_get("@result"))
+
+        sth.finish
+
+        sth = @dbh.prepare("select * from names")
+
+        assert_kind_of DBI::StatementHandle, sth
+        sth.finish
+    end
+
+    def test_bind_param
+        sth = DBI::DBD::SQLite3::Statement.new("select * from names", @dbh.instance_variable_get("@handle").instance_variable_get("@db"))
+
+        assert_raises(DBI::InterfaceError) do
+            sth.bind_param(:foo, "monkeys")
+        end
+
+        sth.finish
+    end
+    
+    def test_column_info
+        @sth = nil
+        
+        assert_nothing_raised do 
+            @sth = @dbh.prepare("select * from names")
+            @sth.execute
+        end
+
+        assert_kind_of Array, @sth.column_info 
+        assert_kind_of DBI::ColumnInfo, @sth.column_info[0]
+        assert_kind_of DBI::ColumnInfo, @sth.column_info[1]
+        assert_equal [ 
+            { 
+                :name  => "name",
+                :sql_type  => 12,
+                :precision  => 255,
+                :type_name  => "varchar"
+            }, 
+            { 
+                :name  => "age",
+                :sql_type  => 4,
+                :type_name  => "integer"
+            } 
+        ], @sth.column_info
+
+        @sth.finish
+    end
+    
+    def test_specific_types
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into db_specific_types_test (dbl) values (?)")
+            @sth.execute(11111111.111111)
+            @sth.execute(22)
+            @sth.finish
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("select * from db_specific_types_test")
+            @sth.execute
+            assert_equal([11111111.111111], @sth.fetch)
+            assert_equal([22], @sth.fetch)
+            @sth.finish
+
+            assert_equal([[11111111.111111], [22]], @dbh.select_all("select * from db_specific_types_test"))
+        end
+
+        assert_nothing_raised do
+            @sth = @dbh.prepare("insert into names (name, age) values (?, ?)")
+            @sth.execute(:joseph, 20)
+            @sth.finish
+
+            @sth = @dbh.prepare("select name, age from names where name=?")
+            @sth.execute("joseph")
+            rows = @sth.fetch_all
+            @sth.finish
+            assert_equal(rows, [["joseph", 20]])
+        end
+    end
+end

data/test/dbd/sqlite3/up.sql

@@ -0,0 +1,33 @@
+create table names (name varchar(255), age integer);
+---
+insert into names (name, age) values ("Bob", 21);
+---
+insert into names (name, age) values ("Joe", 19);
+---
+insert into names (name, age) values ("Jim", 30);
+---
+create table precision_test (text_field varchar(20) primary key not null, integer_field integer, decimal_field decimal(2,1), numeric_field numeric(30,6));
+---
+create view view_names as select * from names;
+---
+create table blob_test (name varchar(255));
+---
+create table boolean_test (num integer, mybool boolean);
+---
+create table time_test (mytime time);
+---
+create table timestamp_test (mytimestamp timestamp);
+---
+create table bit_test (mybit bit);
+---
+create table field_types_test (foo integer not null primary key default 1);
+---
+create table db_specific_types_test (dbl double);
+---
+create table names_defined_with_spaces ( name varchar( 255 ), age integer );
+---
+insert into names_defined_with_spaces (name, age) values ("Bob", 21);
+---
+insert into names_defined_with_spaces (name, age) values ("Joe", 19);
+---
+insert into names_defined_with_spaces (name, age) values ("Jim", 30);

data/test/dbi/tc_dbi.rb

@@ -16,7 +16,7 @@ class TC_DBI < Test::Unit::TestCase
     end
 
     def test_dbi_version
-        assert_equal("0.5.8", DBI::VERSION)
+        assert_equal("0.5.9", DBI::VERSION)
     end
 
     def test_dbd_module

data/test/ts_dbd.rb

@@ -0,0 +1,136 @@
+require 'rubygems'
+gem 'test-unit'
+# figure out what tests to run
+require 'yaml'
+require "test/unit"
+require 'test/unit/ui/console/testrunner'
+
+Dir.chdir("..") if File.basename(Dir.pwd) == "test"
+$LOAD_PATH.unshift(Dir.pwd + "/lib")
+Dir.chdir("test") rescue nil
+$: << '.'
+
+module Test::Unit::Assertions
+    def build_message(head, template=nil, *arguments)
+        template += "\n" + "DATABASE: " + dbtype
+        template &&= template.chomp
+        return AssertionMessage.new(head, template, arguments)
+    end
+end
+
+class Class
+    def name=(klass_name)
+        @name = klass_name
+    end
+
+    def name
+        return @name || super
+    end
+end
+
+module DBDConfig
+    @testbase = { }
+    @current_dbtype = nil
+
+    def self.get_config
+        config = nil
+        if false
+            # ydbi is only interested in testing the postgresql database!!
+            begin
+                config = YAML.load_file(File.join(ENV["HOME"], ".ruby-dbi.test-config.yaml"))
+            rescue Exception => e
+                config = { }
+                config["dbtypes"] = [ ]
+            end
+        else
+            # please keep the definitions in sync between test/ts_dbd.rb and devenv.nix!
+            config = { }
+            config["dbtypes"] = [ "postgresql" ]
+            config["postgresql"] = {"username"=>"ydbi_pg", "password"=>"pg_password", "dbname"=>"ydbi_pg"}
+        end
+        return config
+    end
+
+    def self.inject_sql(dbh, dbtype, file)
+        # splits by --- in the file, strips newlines and the semicolons.
+        # this way we can still manually import the file, but use it with our
+        # drivers for client-independent injection.
+        File.open(file).read.split(/\n*---\n*/, -1).collect { |x| x.gsub!(/\n/, ''); x.sub(/;\z/, '') }.each do |stmt|
+            tmp = STDERR.dup
+            STDERR.reopen('sql.log', 'a')
+            begin
+                dbh.commit rescue nil
+                dbh["AutoCommit"] = true rescue nil
+                dbh.do(stmt)
+                dbh.commit unless dbtype == 'sqlite3'
+            rescue Exception => e
+                tmp.puts "Error injecting '#{stmt}' for db #{dbtype}"
+                tmp.puts "Error: #{e.message}"
+            end
+            STDERR.reopen(tmp)
+        end
+    end
+
+    def self.current_dbtype
+        @current_dbtype
+    end
+
+    def self.current_dbtype=(setting)
+        @current_dbtype = setting
+    end
+
+    def self.testbase(klass_name)
+        return @testbase[klass_name]
+    end
+
+    def self.set_testbase(klass_name, klass)
+        @testbase[klass_name] = klass
+        klass.name = klass_name.to_s
+    end
+
+    def self.suite
+        @suite ||= []
+    end
+end
+
+if __FILE__ == $0
+    Dir.chdir("..") if File.basename(Dir.pwd) == "test"
+    $LOAD_PATH.unshift(File.join(Dir.pwd, "lib"))
+    Dir.chdir("test") rescue nil
+
+    begin
+        require 'dbi'
+    rescue LoadError => e
+        begin
+            require 'rubygems'
+            gem 'dbi'
+            require 'dbi'
+        rescue LoadError => e
+            abort "DBI must already be installed or must come with this package for tests to work."
+        end
+    end
+
+    Deprecate.set_action(proc { })
+
+    config = DBDConfig.get_config
+
+    config["dbtypes"] = ENV["DBTYPES"].split(/\s+/) if ENV["DBTYPES"]
+
+    if config and config["dbtypes"]
+        config["dbtypes"].each do |dbtype|
+            unless config[dbtype]
+                warn "#{dbtype} is selected for testing but not configured; see test/DBD_TESTS" if false
+                next
+            end
+
+            # base.rb is special, see DBD_TESTS
+            require "dbd/#{dbtype}/base.rb"
+            Dir["dbd/#{dbtype}/test*.rb"].each { |file| require file }
+            # run the general tests
+            DBDConfig.current_dbtype = dbtype.to_sym
+            Dir["dbd/general/test*.rb"].each { |file| load file; @class.name = file; DBDConfig.suite << @class }
+        end
+    elsif !config["dbtypes"]
+        warn "Please see test/DBD_TESTS for information on configuring DBD tests."
+    end
+end

data/ydbi.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dbi/version'
+Gem::Specification.new do |gem|
+  gem.name          = 'ydbi'
+  gem.version       = DBI::VERSION
+  gem.authors       = ['Erik Hollensbe', 'Christopher Maujean', 'Niklaus Giger', 'Zeno Davatz']
+  gem.email         = 'zdavatz@ywesee.com'
+  gem.homepage      = 'https://github.com/zdavatz/ydbi'
+  gem.summary       = 'A vendor independent interface for accessing databases, similar to Perl\'s DBI'
+  gem.description   = 'Branch by ywesee com, as our patches were never accepted by upstream'
+  gem.licenses      = ['MIT']
+  gem.files         = `git ls-files`.split($/)
+  gem.test_file     = 'test/ts_dbi.rb'
+  gem.executables   = ['dbi', 'test_broken_dbi']
+  gem.require_paths = ['lib']
+  gem.metadata["changelog_uri"] = gem.homepage + "/blob/master/ChangeLog"
+
+  gem.add_dependency "pg", '>= 1.0.0'
+  gem.add_dependency "bigdecimal"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "test-unit"
+  gem.add_runtime_dependency 'deprecated', '= 2.0.1'
+end

metadata

@@ -1,16 +1,74 @@
 --- !ruby/object:Gem::Specification
 name: ydbi
 version: !ruby/object:Gem::Version
-  version: 0.5.8
+  version: 0.6.0
 platform: ruby
 authors:
 - Erik Hollensbe
 - Christopher Maujean
-autorequire: 
+- Niklaus Giger
+- Zeno Davatz
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-11 00:00:00.000000000 Z
+date: 2024-01-30 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: deprecated
   requirement: !ruby/object:Gem::Requirement
@@ -31,19 +89,53 @@ executables:
 - dbi
 - test_broken_dbi
 extensions: []
-extra_rdoc_files:
-- readme.md
-- LICENSE
-- ChangeLog
+extra_rdoc_files: []
 files:
+- ".envrc"
+- ".github/workflows/ruby.yml"
+- ".gitignore"
 - ChangeLog
+- Gemfile
 - LICENSE
+- Rakefile
+- TODO
+- bench/bench.rb
 - bin/dbi
 - bin/test_broken_dbi
 - build/Rakefile.dbi.rb
+- build/rake_task_lib.rb
+- devenv.lock
+- devenv.nix
+- devenv.yaml
+- doc/DBD_SPEC.rdoc
+- doc/DBI_SPEC.rdoc
+- doc/homepage/contact.html
+- doc/homepage/development.html
+- doc/homepage/index.html
+- doc/homepage/ruby-dbi.css
 - examples/test1.pl
 - examples/test1.rb
 - examples/xmltest.rb
+- lib/dbd/Mysql.rb
+- lib/dbd/ODBC.rb
+- lib/dbd/Pg.rb
+- lib/dbd/SQLite.rb
+- lib/dbd/SQLite3.rb
+- lib/dbd/mysql/database.rb
+- lib/dbd/mysql/driver.rb
+- lib/dbd/mysql/statement.rb
+- lib/dbd/odbc/database.rb
+- lib/dbd/odbc/driver.rb
+- lib/dbd/odbc/statement.rb
+- lib/dbd/pg/database.rb
+- lib/dbd/pg/exec.rb
+- lib/dbd/pg/statement.rb
+- lib/dbd/pg/tuples.rb
+- lib/dbd/pg/type.rb
+- lib/dbd/sqlite/database.rb
+- lib/dbd/sqlite/statement.rb
+- lib/dbd/sqlite3/database.rb
+- lib/dbd/sqlite3/statement.rb
 - lib/dbi.rb
 - lib/dbi/base_classes.rb
 - lib/dbi/base_classes/database.rb
@@ -70,7 +162,48 @@ files:
 - lib/dbi/utils/timestamp.rb
 - lib/dbi/utils/xmlformatter.rb
 - lib/dbi/version.rb
+- prototypes/types2.rb
 - readme.md
+- setup.rb
+- test/DBD_TESTS
+- test/TESTING
+- test/dbd/general/test_database.rb
+- test/dbd/general/test_statement.rb
+- test/dbd/general/test_types.rb
+- test/dbd/mysql/base.rb
+- test/dbd/mysql/down.sql
+- test/dbd/mysql/test_blob.rb
+- test/dbd/mysql/test_new_methods.rb
+- test/dbd/mysql/test_patches.rb
+- test/dbd/mysql/up.sql
+- test/dbd/odbc/base.rb
+- test/dbd/odbc/down.sql
+- test/dbd/odbc/test_new_methods.rb
+- test/dbd/odbc/test_ping.rb
+- test/dbd/odbc/test_statement.rb
+- test/dbd/odbc/test_transactions.rb
+- test/dbd/odbc/up.sql
+- test/dbd/postgresql/base.rb
+- test/dbd/postgresql/down.sql
+- test/dbd/postgresql/test_arrays.rb
+- test/dbd/postgresql/test_async.rb
+- test/dbd/postgresql/test_blob.rb
+- test/dbd/postgresql/test_bytea.rb
+- test/dbd/postgresql/test_ping.rb
+- test/dbd/postgresql/test_timestamp.rb
+- test/dbd/postgresql/test_transactions.rb
+- test/dbd/postgresql/testdbipg.rb
+- test/dbd/postgresql/up.sql
+- test/dbd/sqlite/base.rb
+- test/dbd/sqlite/test_database.rb
+- test/dbd/sqlite/test_driver.rb
+- test/dbd/sqlite/test_statement.rb
+- test/dbd/sqlite/up.sql
+- test/dbd/sqlite3/base.rb
+- test/dbd/sqlite3/test_database.rb
+- test/dbd/sqlite3/test_driver.rb
+- test/dbd/sqlite3/test_statement.rb
+- test/dbd/sqlite3/up.sql
 - test/dbi/tc_columninfo.rb
 - test/dbi/tc_date.rb
 - test/dbi/tc_dbi.rb
@@ -80,12 +213,15 @@ files:
 - test/dbi/tc_time.rb
 - test/dbi/tc_timestamp.rb
 - test/dbi/tc_types.rb
+- test/ts_dbd.rb
 - test/ts_dbi.rb
+- ydbi.gemspec
 homepage: https://github.com/zdavatz/ydbi
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  changelog_uri: https://github.com/zdavatz/ydbi/blob/master/ChangeLog
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -93,15 +229,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.0
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.4
-signing_key: 
+rubygems_version: 3.5.3
+signing_key:
 specification_version: 4
 summary: A vendor independent interface for accessing databases, similar to Perl's
   DBI