serrano-vk 0.1.0

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/jdbc/postgresql.rb

@@ -0,0 +1,239 @@
+# frozen-string-literal: true
+
+Sequel::JDBC.load_driver('Java::OrgPostgresql::Driver', :Postgres)
+require_relative '../shared/postgres'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:postgresql] = proc do |db|
+        db.dataset_class = Sequel::JDBC::Postgres::Dataset
+        db.extend(Sequel::JDBC::Postgres::DatabaseMethods)
+        Java::OrgPostgresql::Driver
+      end
+    end
+
+    module Postgres
+      module DatabaseMethods
+        include Sequel::Postgres::DatabaseMethods
+
+        # Add the primary_keys and primary_key_sequences instance variables,
+        # so we can get the correct return values for inserted rows.
+        def self.extended(db)
+          super
+          db.send(:initialize_postgres_adapter)
+        end
+
+        # Remove any current entry for the oid in the oid_convertor_map.
+        def add_conversion_proc(oid, *)
+          super
+          Sequel.synchronize{@oid_convertor_map.delete(oid)}
+        end
+
+        # See Sequel::Postgres::Adapter#copy_into
+        def copy_into(table, opts=OPTS)
+          data = opts[:data]
+          data = Array(data) if data.is_a?(String)
+
+          if defined?(yield) && data
+            raise Error, "Cannot provide both a :data option and a block to copy_into"
+          elsif !defined?(yield) && !data
+            raise Error, "Must provide either a :data option or a block to copy_into"
+          end
+
+          synchronize(opts[:server]) do |conn|
+            begin
+              copy_manager = Java::OrgPostgresqlCopy::CopyManager.new(conn)
+              copier = copy_manager.copy_in(copy_into_sql(table, opts))
+              if defined?(yield)
+                while buf = yield
+                  java_bytes = buf.to_java_bytes
+                  copier.writeToCopy(java_bytes, 0, java_bytes.length)
+                end
+              else
+                data.each do |d|
+                  java_bytes = d.to_java_bytes
+                  copier.writeToCopy(java_bytes, 0, java_bytes.length)
+                end
+              end
+            rescue Exception => e
+              copier.cancelCopy if copier
+              raise
+            ensure
+              unless e
+                begin
+                  copier.endCopy
+                rescue NativeException => e2
+                  raise_error(e2)
+                end
+              end
+            end
+          end
+        end
+        
+        # See Sequel::Postgres::Adapter#copy_table
+        def copy_table(table, opts=OPTS)
+          synchronize(opts[:server]) do |conn|
+            copy_manager = Java::OrgPostgresqlCopy::CopyManager.new(conn)
+            copier = copy_manager.copy_out(copy_table_sql(table, opts))
+            begin
+              if defined?(yield)
+                while buf = copier.readFromCopy
+                  yield(String.from_java_bytes(buf))
+                end
+                nil
+              else
+                b = String.new
+                while buf = copier.readFromCopy
+                  b << String.from_java_bytes(buf)
+                end
+                b
+              end
+            rescue => e
+              raise_error(e, :disconnect=>true)
+            ensure
+              if buf && !e
+                raise DatabaseDisconnectError, "disconnecting as a partial COPY may leave the connection in an unusable state"
+              end
+            end
+          end
+        end
+
+        def oid_convertor_proc(oid)
+          if (conv = Sequel.synchronize{@oid_convertor_map[oid]}).nil?
+            conv = if pr = conversion_procs[oid]
+              lambda do |r, i|
+                if v = r.getString(i)
+                  pr.call(v)
+                end
+              end
+            else
+              false
+            end
+            Sequel.synchronize{@oid_convertor_map[oid] = conv}
+          end
+          conv
+        end
+
+        private
+        
+        def disconnect_error?(exception, opts)
+          super || exception.message =~ /\A(This connection has been closed\.|FATAL: terminating connection due to administrator command|An I\/O error occurred while sending to the backend\.)\z/
+        end
+
+        # For PostgreSQL-specific types, return the string that should be used
+        # as the PGObject value. Returns nil by default, loading pg_* extensions
+        # will override this to add support for specific types.
+        def bound_variable_arg(arg, conn)
+          nil
+        end
+
+        # Work around issue when using Sequel's bound variable support where the
+        # same SQL is used in different bound variable calls, but the schema has
+        # changed between the calls.  This is necessary as jdbc-postgres versions
+        # after 9.4.1200 violate the JDBC API.  These versions cache separate
+        # PreparedStatement instances, which are eventually prepared server side after the
+        # prepareThreshold is met.  The JDBC API violation is that PreparedStatement#close
+        # does not release the server side prepared statement.
+        def prepare_jdbc_statement(conn, sql, opts)
+          ps = super
+          unless opts[:name]
+            ps.prepare_threshold = 0
+          end
+          ps
+        end
+
+        # If the given argument is a recognized PostgreSQL-specific type, create
+        # a PGObject instance with unknown type and the bound argument string value,
+        # and set that as the prepared statement argument.
+        def set_ps_arg(cps, arg, i)
+          if v = bound_variable_arg(arg, nil)
+            obj = Java::OrgPostgresqlUtil::PGobject.new
+            obj.setType("unknown")
+            obj.setValue(v)
+            cps.setObject(i, obj)
+          else
+            super
+          end
+        end
+
+        # Use setNull for nil arguments as the default behavior of setString
+        # with nil doesn't appear to work correctly on PostgreSQL.
+        def set_ps_arg_nil(cps, i)
+          cps.setNull(i, JavaSQL::Types::NULL)
+        end
+
+        # Execute the connection configuration SQL queries on the connection.
+        def setup_connection_with_opts(conn, opts)
+          conn = super
+          statement(conn) do |stmt|
+            connection_configuration_sqls(opts).each{|sql| log_connection_yield(sql, conn){stmt.execute(sql)}}
+          end
+          conn
+        end
+
+        def setup_type_convertor_map
+          super
+          @oid_convertor_map = {}
+        end
+      end
+      
+      class Dataset < JDBC::Dataset
+        include Sequel::Postgres::DatasetMethods
+
+        # Warn when calling as the fetch size is ignored by the JDBC adapter currently.
+        def with_fetch_size(size)
+          warn("Sequel::JDBC::Postgres::Dataset#with_fetch_size does not currently have an effect.", :uplevel=>1)
+          super
+        end
+        
+        private
+        
+        # Literalize strings similar to the native postgres adapter
+        def literal_string_append(sql, v)
+          sql << "'" << db.synchronize(@opts[:server]){|c| c.escape_string(v)} << "'"
+        end
+
+        # SQL fragment for Sequel::SQLTime, containing just the time part
+        def literal_sqltime(v)
+          v.strftime("'%H:%M:%S#{sprintf(".%03d", (v.usec/1000.0).round)}'")
+        end
+
+        INTEGER_TYPE = Java::JavaSQL::Types::INTEGER
+        STRING_TYPE = Java::JavaSQL::Types::VARCHAR
+        ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
+        PG_SPECIFIC_TYPES = [Java::JavaSQL::Types::ARRAY, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
+
+        # Return PostgreSQL hstore types as ruby Hashes instead of
+        # Java HashMaps.  Only used if the database does not have a
+        # conversion proc for the type.
+        HSTORE_METHOD = Object.new
+        def HSTORE_METHOD.call(r, i)
+          if v = r.getObject(i)
+            v.to_hash
+          end
+        end 
+
+        def type_convertor(map, meta, type, i)
+          case type
+          when *PG_SPECIFIC_TYPES
+            oid = meta.getField(i).getOID
+            if pr = db.oid_convertor_proc(oid)
+              pr
+            elsif oid == 28 # XID (Transaction ID)
+              map[INTEGER_TYPE]
+            elsif oid == 2950 # UUID
+              map[STRING_TYPE]
+            elsif meta.getPGType(i) == 'hstore'
+              HSTORE_METHOD
+            else
+              super
+            end
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/jdbc/sqlanywhere.rb

@@ -0,0 +1,87 @@
+# frozen-string-literal: true
+
+require_relative '../shared/sqlanywhere'
+require_relative 'transactions'
+
+module Sequel
+  module JDBC
+    drv = [
+      lambda{Java::SybaseJdbc4Sqlanywhere::IDriver},
+      lambda{Java::IanywhereMlJdbcodbcJdbc4::IDriver},
+      lambda{Java::SybaseJdbcSqlanywhere::IDriver},
+      lambda{Java::IanywhereMlJdbcodbcJdbc::IDriver},
+      lambda{Java::ComSybaseJdbc4Jdbc::Sybdriver},
+      lambda{Java::ComSybaseJdbc3Jdbc::Sybdriver}
+    ].each do |class_proc|
+      begin
+        break class_proc.call
+      rescue NameError
+      end
+    end
+    raise(Sequel::AdapterNotFound, "no suitable SQLAnywhere JDBC driver found") unless drv
+
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlanywhere] = proc do |db|
+        db.extend(Sequel::JDBC::SqlAnywhere::DatabaseMethods)
+        db.convert_smallint_to_bool = true
+        db.dataset_class = Sequel::JDBC::SqlAnywhere::Dataset
+        drv
+      end
+    end
+
+    module SqlAnywhere
+      module DatabaseMethods
+        include Sequel::SqlAnywhere::DatabaseMethods
+        include Sequel::JDBC::Transactions
+
+        private
+
+        def database_exception_use_sqlstates?
+          false
+        end
+
+        # Use @@IDENTITY to get the last inserted id
+        def last_insert_id(conn, opts=OPTS)
+          statement(conn) do |stmt|
+            sql = 'SELECT @@IDENTITY'
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
+            rs.next
+            rs.getLong(1)
+          end
+        end
+      end
+
+      class Dataset < JDBC::Dataset
+        include Sequel::SqlAnywhere::DatasetMethods
+
+        private
+
+        # JDBC SQLAnywhere driver does not appear to handle fractional
+        # times correctly.
+        def default_time_format
+          "'%H:%M:%S'"
+        end
+
+        # Set to zero to work around JDBC SQLAnywhere driver bug.
+        def sqltime_precision
+          0
+        end
+
+        SMALLINT_TYPE = Java::JavaSQL::Types::SMALLINT
+        BOOLEAN_METHOD = Object.new
+        def BOOLEAN_METHOD.call(r, i)
+          v = r.getShort(i)
+          v != 0 unless r.wasNull
+        end
+
+        def type_convertor(map, meta, type, i)
+          if convert_smallint_to_bool && type == SMALLINT_TYPE
+            BOOLEAN_METHOD
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/jdbc/sqlite.rb

@@ -0,0 +1,133 @@
+# frozen-string-literal: true
+
+Sequel::JDBC.load_driver('Java::OrgSqlite::JDBC', :SQLite3)
+require_relative '../shared/sqlite'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlite] = proc do |db|
+        db.extend(Sequel::JDBC::SQLite::DatabaseMethods)
+        db.extend_datasets Sequel::SQLite::DatasetMethods
+        db.set_integer_booleans
+        Java::OrgSqlite::JDBC
+      end
+    end
+
+    module SQLite
+      module ForeignKeyListPragmaConvertorFix
+        # For the use of the convertor for String, working around a bug
+        # in jdbc-sqlite3 that reports fields are of type
+        # java.sql.types.NUMERIC even though they contain non-numeric data.
+        def type_convertor(_, _, _, i)
+          i > 2 ? TypeConvertor::CONVERTORS[:String] : super
+        end
+      end
+
+      module TableInfoPragmaConvertorFix
+        # For the use of the convertor for String, working around a bug
+        # in jdbc-sqlite3 that reports dflt_value field is of type
+        # java.sql.types.NUMERIC even though they contain string data.
+        def type_convertor(_, _, _, i)
+          i == 5 ? TypeConvertor::CONVERTORS[:String] : super
+        end
+      end
+
+      module DatabaseMethods
+        include Sequel::SQLite::DatabaseMethods
+        
+        # Swallow pointless exceptions when the foreign key list pragma
+        # doesn't return any rows.
+        def foreign_key_list(table, opts=OPTS)
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless foreign_key_error?(e)
+          []
+        end
+
+        # Swallow pointless exceptions when the index list pragma
+        # doesn't return any rows.
+        def indexes(table, opts=OPTS)
+          super
+        rescue Sequel::DatabaseError => e
+          raise unless foreign_key_error?(e)
+          {}
+        end
+
+        private
+
+
+        # Add workaround for bug when running foreign_key_list pragma
+        def _foreign_key_list_ds(_)
+          super.with_extend(ForeignKeyListPragmaConvertorFix)
+        end
+
+        # Add workaround for bug when running table_info pragma
+        def _parse_pragma_ds(_, _)
+          super.with_extend(TableInfoPragmaConvertorFix)
+        end
+        
+        DATABASE_ERROR_REGEXPS = Sequel::SQLite::DatabaseMethods::DATABASE_ERROR_REGEXPS.merge(/Abort due to constraint violation/ => ConstraintViolation).freeze
+        def database_error_regexps
+          DATABASE_ERROR_REGEXPS
+        end
+
+        # Use last_insert_rowid() to get the last inserted id.
+        def last_insert_id(conn, opts=OPTS)
+          statement(conn) do |stmt|
+            rs = stmt.executeQuery('SELECT last_insert_rowid()')
+            rs.next
+            rs.getLong(1)
+          end
+        end
+        
+        # Default to a single connection for a memory database.
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:sqlite::memory:' ? o.merge(:max_connections=>1) : o
+        end
+        
+        # Execute the connection pragmas on the connection.
+        def setup_connection(conn)
+          conn = super(conn)
+          statement(conn) do |stmt|
+            connection_pragmas.each{|s| log_connection_yield(s, conn){stmt.execute(s)}}
+          end
+          conn
+        end
+
+        # Whether the given exception is due to a foreign key error.
+        def foreign_key_error?(exception)
+          exception.message.include?('query does not return ResultSet')
+        end
+
+        # Use getLong instead of getInt for converting integers on SQLite, since SQLite does not enforce a limit of 2**32.
+        # Work around regressions in jdbc-sqlite 3.8.7 for date and blob types.
+        def setup_type_convertor_map
+          super
+          @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
+          @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
+          x = @type_convertor_map[Java::JavaSQL::Types::DATE] = Object.new
+          def x.call(r, i)
+            if v = r.getString(i)
+              Sequel.string_to_date(v)
+            end
+          end
+          x = @type_convertor_map[Java::JavaSQL::Types::BLOB] = Object.new
+          def x.call(r, i)
+            if v = r.getBytes(i)
+              Sequel::SQL::Blob.new(String.from_java_bytes(v))
+            elsif !r.wasNull
+              Sequel::SQL::Blob.new('')
+            end
+          end
+        end
+
+        # The result code for the exception, if the jdbc driver supports result codes for exceptions.
+        def sqlite_error_code(exception)
+          exception.resultCode.code if exception.respond_to?(:resultCode)
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/jdbc/sqlserver.rb

@@ -0,0 +1,92 @@
+# frozen-string-literal: true
+
+Sequel::JDBC.load_driver('Java::ComMicrosoftSqlserverJdbc::SQLServerDriver')
+require_relative 'mssql'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:sqlserver] = proc do |db|
+        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
+        db.extend_datasets Sequel::MSSQL::DatasetMethods
+        db.send(:set_mssql_unicode_strings)
+        Java::ComMicrosoftSqlserverJdbc::SQLServerDriver
+      end
+    end
+
+    module SQLServer
+      MSSQL_RUBY_TIME = Object.new
+      def MSSQL_RUBY_TIME.call(r, i)
+        # MSSQL-Server TIME should be fetched as string to keep the precision intact, see:
+        # https://docs.microsoft.com/en-us/sql/t-sql/data-types/time-transact-sql#a-namebackwardcompatibilityfordownlevelclientsa-backward-compatibility-for-down-level-clients
+        if v = r.getString(i)
+          Sequel.string_to_time("#{v}")
+        end
+      end
+
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+
+        def setup_type_convertor_map
+          super
+          map = @type_convertor_map
+          map[Java::JavaSQL::Types::TIME] = MSSQL_RUBY_TIME
+
+          # Work around constant lazy loading in some drivers
+          begin
+            dto = Java::MicrosoftSql::Types::DATETIMEOFFSET
+          rescue NameError
+          end
+
+          if dto
+            map[dto] = lambda do |r, i|
+              if v = r.getDateTimeOffset(i)
+                to_application_timestamp(v.to_s)
+              end
+            end
+          end
+        end
+
+        # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
+        # for the getColumns result set specifies an incorrect type for the
+        # IS_AUTOINCREMENT column. The column is a string, but the type is
+        # specified as a short. This causes getObject() to throw a
+        # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
+        # from char to SMALLINT is unsupported." Using getString() rather
+        # than getObject() for this column avoids the problem.
+        # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
+        module MetadataDatasetMethods
+          def type_convertor(map, meta, type, i)
+            if output_identifier(meta.getColumnLabel(i)) == :is_autoincrement
+              map[Java::JavaSQL::Types::VARCHAR]
+            else
+              super
+            end
+          end
+
+          def basic_type_convertor(map, meta, type, i)
+            if output_identifier(meta.getColumnLabel(i)) == :is_autoincrement
+              map[Java::JavaSQL::Types::VARCHAR]
+            else
+              super
+            end
+          end
+        end
+        
+        private
+
+        def _metadata_dataset
+          super.with_extend(MetadataDatasetMethods)
+        end
+
+        def database_exception_use_sqlstates?
+          false
+        end
+
+        def disconnect_error?(exception, opts)
+          super || (exception.message.include?('connection is closed'))
+        end
+      end
+    end
+  end
+end

data/examples/demo_crud/vendor/bundle/ruby/3.4.0/gems/sequel-5.102.0/lib/sequel/adapters/jdbc/transactions.rb

@@ -0,0 +1,95 @@
+# frozen-string-literal: true
+
+module Sequel
+  module JDBC
+    module Transactions
+      def freeze
+        supports_savepoints?
+        super
+      end
+
+      # Check the JDBC DatabaseMetaData for savepoint support
+      def supports_savepoints?
+        return @supports_savepoints if defined?(@supports_savepoints)
+        @supports_savepoints = synchronize{|c| c.getMetaData.supports_savepoints}
+      end
+
+      # Check the JDBC DatabaseMetaData for support for serializable isolation,
+      # since that's the value most people will use.
+      def supports_transaction_isolation_levels?
+        synchronize{|conn| conn.getMetaData.supportsTransactionIsolationLevel(JavaSQL::Connection::TRANSACTION_SERIALIZABLE)}
+      end
+
+      private
+
+      JDBC_TRANSACTION_ISOLATION_LEVELS = {:uncommitted=>JavaSQL::Connection::TRANSACTION_READ_UNCOMMITTED,
+        :committed=>JavaSQL::Connection::TRANSACTION_READ_COMMITTED,
+        :repeatable=>JavaSQL::Connection::TRANSACTION_REPEATABLE_READ,
+        :serializable=>JavaSQL::Connection::TRANSACTION_SERIALIZABLE}.freeze
+
+      # Set the transaction isolation level on the given connection using
+      # the JDBC API.
+      def set_transaction_isolation(conn, opts)
+        level = opts.fetch(:isolation, transaction_isolation_level)
+        if (jdbc_level = JDBC_TRANSACTION_ISOLATION_LEVELS[level]) &&
+            conn.getMetaData.supportsTransactionIsolationLevel(jdbc_level)
+          _trans(conn)[:original_jdbc_isolation_level] = conn.getTransactionIsolation
+          log_connection_yield("Transaction.isolation_level = #{level}", conn){conn.setTransactionIsolation(jdbc_level)}
+        end
+      end
+
+      # Most JDBC drivers that support savepoints support releasing them.
+      def supports_releasing_savepoints?
+        true
+      end
+
+      # JDBC savepoint object for the current savepoint for the connection.
+      def savepoint_obj(conn)
+        _trans(conn)[:savepoints][-1][:obj]
+      end
+
+      # Use JDBC connection's setAutoCommit to false to start transactions
+      def begin_transaction(conn, opts=OPTS)
+        if in_savepoint?(conn)
+          _trans(conn)[:savepoints][-1][:obj] = log_connection_yield('Transaction.savepoint', conn){conn.set_savepoint}
+        else
+          log_connection_yield('Transaction.begin', conn){conn.setAutoCommit(false)}
+          set_transaction_isolation(conn, opts)
+        end
+      end
+      
+      # Use JDBC connection's commit method to commit transactions
+      def commit_transaction(conn, opts=OPTS)
+        if in_savepoint?(conn)
+          if supports_releasing_savepoints?
+            log_connection_yield('Transaction.release_savepoint', conn){conn.release_savepoint(savepoint_obj(conn))}
+          end
+        else
+          log_connection_yield('Transaction.commit', conn){conn.commit}
+        end
+      end
+      
+      # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
+      def remove_transaction(conn, committed)
+        if jdbc_level = _trans(conn)[:original_jdbc_isolation_level]
+          log_connection_yield("Transaction.restore_isolation_level", conn){conn.setTransactionIsolation(jdbc_level)}
+        end
+        unless in_savepoint?(conn)
+          conn.setAutoCommit(true)
+        end
+      ensure
+        super
+      end
+      
+      # Use JDBC connection's rollback method to rollback transactions
+      def rollback_transaction(conn, opts=OPTS)
+        if in_savepoint?(conn)
+          log_connection_yield('Transaction.rollback_savepoint', conn){conn.rollback(savepoint_obj(conn))}
+        else
+          log_connection_yield('Transaction.rollback', conn){conn.rollback}
+        end
+      end
+    end
+  end
+end
+