serrano-vk 0.1.0

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

@@ -0,0 +1,228 @@
+# frozen-string-literal: true
+
+Sequel::JDBC.load_driver('Java::OrgHsqldb::jdbcDriver', :HSQLDB)
+require_relative 'transactions'
+require_relative '../../extensions/auto_cast_date_and_time'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:hsqldb] = proc do |db|
+        db.extend(Sequel::JDBC::HSQLDB::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::HSQLDB::Dataset
+        Java::OrgHsqldb::jdbcDriver
+      end
+    end
+
+    module HSQLDB
+      module DatabaseMethods
+        include AutoCastDateAndTime
+        include ::Sequel::JDBC::Transactions
+
+        def database_type
+          :hsqldb
+        end
+
+        def freeze
+          db_version
+          super
+        end
+
+        # HSQLDB uses an IDENTITY sequence as the default value for primary
+        # key columns.
+        def serial_primary_key_options
+          {:primary_key => true, :type => :integer, :identity=>true, :start_with=>1}
+        end
+
+        # The version of the database, as an integer (e.g 2.2.5 -> 20205)
+        def db_version
+          return @db_version if defined?(@db_version)
+          v = get(Sequel.function(:DATABASE_VERSION))
+          @db_version = if v =~ /(\d+)\.(\d+)\.(\d+)/
+            $1.to_i * 10000 + $2.to_i * 100 + $3.to_i
+          end
+        end
+        
+        # HSQLDB supports DROP TABLE IF EXISTS
+        def supports_drop_table_if_exists?
+          true
+        end
+
+        private
+        
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :add_column
+            if op[:table]
+              [super(table, op.merge(:table=>nil)),
+               alter_table_sql(table, op.merge(:op=>:add_constraint, :type=>:foreign_key, :name=>op[:foreign_key_constraint_name], :columns=>[op[:name]], :table=>op[:table]))]
+            else
+              super
+            end
+          when :rename_column
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} RENAME TO #{quote_identifier(op[:new_name])}"
+          when :set_column_type
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET DATA TYPE #{type_literal(op)}"
+          when :set_column_null
+            "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} SET #{op[:null] ? 'NULL' : 'NOT NULL'}"
+          else
+            super
+          end
+        end
+
+        # HSQLDB requires parens around the SELECT, and the WITH DATA syntax.
+        def create_table_as_sql(name, sql, options)
+          "#{create_table_prefix_sql(name, options)} AS (#{sql}) WITH DATA"
+        end
+
+        DATABASE_ERROR_REGEXPS = {
+          /integrity constraint violation: unique constraint or index violation/ => UniqueConstraintViolation,
+          /integrity constraint violation: foreign key/ => ForeignKeyConstraintViolation,
+          /integrity constraint violation: check constraint/ => CheckConstraintViolation,
+          /integrity constraint violation: NOT NULL check constraint/ => NotNullConstraintViolation,
+          /serialization failure/ => SerializationFailure,
+        }.freeze
+        def database_error_regexps
+          DATABASE_ERROR_REGEXPS
+        end
+
+        # IF EXISTS comes after table name on HSQLDB
+        def drop_table_sql(name, options)
+          "DROP TABLE #{quote_schema_table(name)}#{' IF EXISTS' if options[:if_exists]}#{' CASCADE' if options[:cascade]}"
+        end
+        
+        # IF EXISTS comes after view name on HSQLDB
+        def drop_view_sql(name, options)
+          "DROP VIEW #{quote_schema_table(name)}#{' IF EXISTS' if options[:if_exists]}#{' CASCADE' if options[:cascade]}"
+        end
+
+        # Use IDENTITY() to get the last inserted id.
+        def last_insert_id(conn, opts=OPTS)
+          statement(conn) do |stmt|
+            sql = 'CALL IDENTITY()'
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
+            rs.next
+            rs.getLong(1)
+          end
+        end
+        
+        # Primary key indexes appear to start with sys_idx_sys_pk_ on HSQLDB
+        def primary_key_index_re
+          /\Asys_idx_sys_pk_/i
+        end
+
+        # If an :identity option is present in the column, add the necessary IDENTITY SQL.
+        # It's possible to use an IDENTITY type, but that defaults the sequence to start
+        # at 0 instead of 1, and we don't want that.
+        def type_literal(column)
+          if column[:identity]
+            sql = "#{super} GENERATED BY DEFAULT AS IDENTITY"
+            if sw = column[:start_with]
+              sql += " (START WITH #{sw.to_i}"
+              sql << " INCREMENT BY #{column[:increment_by].to_i}" if column[:increment_by]
+              sql << ")"
+            end
+            sql
+          else
+            super
+          end
+        end
+
+        # HSQLDB uses clob for text types.
+        def uses_clob_for_text?
+          true
+        end
+
+        # HSQLDB supports views with check option.
+        def view_with_check_option_support
+          :local
+        end
+      end
+      
+      class Dataset < JDBC::Dataset
+        # Handle HSQLDB specific case insensitive LIKE and bitwise operator support.
+        def complex_expression_sql_append(sql, op, args)
+          case op
+          when :ILIKE, :"NOT ILIKE"
+            super(sql, (op == :ILIKE ? :LIKE : :"NOT LIKE"), args.map{|v| SQL::Function.new(:ucase, v)})
+          when :&, :|, :^, :%, :<<, :>>, :'B~'
+            complex_expression_emulate_append(sql, op, args)
+          else
+            super
+          end
+        end
+
+        # HSQLDB requires recursive CTEs to have column aliases.
+        def recursive_cte_requires_column_aliases?
+          true
+        end
+
+        # HSQLDB requires SQL standard datetimes in some places.
+        def requires_sql_standard_datetimes?
+          true
+        end
+
+        # HSQLDB does support common table expressions, but the support is broken.
+        # CTEs operate more like temprorary tables or views, lasting longer than the duration of the expression.
+        # CTEs in earlier queries might take precedence over CTEs with the same name in later queries.
+        # Also, if any CTE is recursive, all CTEs must be recursive.
+        # If you want to use CTEs with HSQLDB, you'll have to manually modify the dataset to allow it.
+        def supports_cte?(type=:select)
+          false
+        end
+
+        # HSQLDB does not support IS TRUE.
+        def supports_is_true?
+          false
+        end
+
+        # HSQLDB supports lateral subqueries.
+        def supports_lateral_subqueries?
+          true
+        end
+
+        # HSQLDB 2.3.4+ supports MERGE.  Older versions also support MERGE, but not all
+        # features that are in Sequel's tests.
+        def supports_merge?
+          db.db_version >= 20304
+        end
+
+        private
+
+        def empty_from_sql
+          " FROM (VALUES (0))"
+        end
+        
+        # Use string in hex format for blob data.
+        def literal_blob_append(sql, v)
+          sql << "X'" << v.unpack("H*").first << "'"
+        end
+
+        # HSQLDB uses FALSE for false values.
+        def literal_false
+          'FALSE'
+        end
+
+        # HSQLDB handles fractional seconds in timestamps, but not in times
+        def literal_sqltime(v)
+          v.strftime("'%H:%M:%S'")
+        end
+
+        # HSQLDB uses TRUE for true values.
+        def literal_true
+          'TRUE'
+        end
+
+        # HSQLDB supports multiple rows in INSERT.
+        def multi_insert_sql_strategy
+          :values
+        end
+
+        # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
+        def select_with_sql_base
+          opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+
+Sequel::JDBC.load_driver('Java::NetSourceforgeJtdsJdbc::Driver', :JTDS)
+require_relative 'mssql'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:jtds] = proc do |db|
+        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
+        db.extend_datasets Sequel::MSSQL::DatasetMethods
+        db.send(:set_mssql_unicode_strings)
+        Java::NetSourceforgeJtdsJdbc::Driver
+      end
+    end
+
+    module JTDS
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+
+        private
+
+        # JTDS exception handling with SQLState is less accurate than with regexps.
+        def database_exception_use_sqlstates?
+          false
+        end
+
+        def disconnect_error?(exception, opts)
+          super || exception.message =~ /\AInvalid state, the Connection object is closed\.\z/
+        end
+
+        # Handle nil values by using setNull with the correct parameter type.
+        def set_ps_arg_nil(cps, i)
+          cps.setNull(i, cps.getParameterMetaData.getParameterType(i))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen-string-literal: true
+
+require_relative '../shared/mssql'
+
+module Sequel
+  module JDBC
+    module MSSQL
+      module DatabaseMethods
+        include Sequel::MSSQL::DatabaseMethods
+        
+        private
+        
+        # Get the last inserted id using SCOPE_IDENTITY().
+        def last_insert_id(conn, opts=OPTS)
+          statement(conn) do |stmt|
+            sql = opts[:prepared] ? 'SELECT @@IDENTITY' : 'SELECT SCOPE_IDENTITY()'
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
+            rs.next
+            rs.getLong(1)
+          end
+        end
+        
+        # Primary key indexes appear to start with pk__ on MSSQL
+        def primary_key_index_re
+          /\Apk__/i
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# frozen-string-literal: true
+
+module Sequel
+  module JDBC
+    driver = Sequel::JDBC.load_driver(%w'Java::ComMysqlCjJdbc::Driver Java::ComMysqlJdbc::Driver', :MySQL)
+    require_relative '../shared/mysql'
+
+    Sequel.synchronize do
+      DATABASE_SETUP[:mysql] = proc do |db|
+        db.extend(Sequel::JDBC::MySQL::DatabaseMethods)
+        db.extend_datasets Sequel::MySQL::DatasetMethods
+        driver
+      end
+    end
+
+    module MySQL
+      module DatabaseMethods
+        include Sequel::MySQL::DatabaseMethods
+        
+        private
+        
+        # MySQL exception handling with SQLState is less accurate than with regexps.
+        def database_exception_use_sqlstates?
+          false
+        end
+
+        # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
+        def disconnect_error?(exception, opts)
+          exception.message.start_with?("Communications link failure") || super
+        end
+
+        # Get the last inserted id using LAST_INSERT_ID().
+        def last_insert_id(conn, opts=OPTS)
+          if stmt = opts[:stmt]
+            rs = stmt.getGeneratedKeys
+            begin
+              if rs.next
+                rs.getLong(1)
+              else
+                0
+              end
+            ensure
+              rs.close
+            end
+          else
+            statement(conn) do |st|
+              rs = st.executeQuery('SELECT LAST_INSERT_ID()')
+              rs.next
+              rs.getLong(1)
+            end
+          end
+        end
+
+        # MySQL 5.1.12 JDBC adapter requires generated keys
+        # and previous versions don't mind.
+        def execute_statement_insert(stmt, sql)
+          stmt.executeUpdate(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS)
+        end
+
+        # Return generated keys for insert statements.
+        def prepare_jdbc_statement(conn, sql, opts)
+          opts[:type] == :insert ? conn.prepareStatement(sql, JavaSQL::Statement::RETURN_GENERATED_KEYS) : super
+        end
+
+        # Convert tinyint(1) type to boolean
+        def schema_column_type(db_type)
+          db_type.start_with?("tinyint(1)") ? :boolean : super
+        end
+      
+        # Run the default connection setting SQL statements.
+        # Apply the connectiong setting SQLs for every new connection.
+        def setup_connection(conn)
+          mysql_connection_setting_sqls.each{|sql| statement(conn){|s| log_connection_yield(sql, conn){s.execute(sql)}}}
+          super
+        end
+
+        # Handle unsigned integer values
+        def setup_type_convertor_map
+          super
+          TypeConvertor::BASIC_MAP.dup
+          @type_convertor_map[Java::JavaSQL::Types::SMALLINT] = @type_convertor_map[Java::JavaSQL::Types::INTEGER]
+          @type_convertor_map[Java::JavaSQL::Types::INTEGER] = @type_convertor_map[Java::JavaSQL::Types::BIGINT]
+          @basic_type_convertor_map[Java::JavaSQL::Types::SMALLINT] = @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER]
+          @basic_type_convertor_map[Java::JavaSQL::Types::INTEGER] = @basic_type_convertor_map[Java::JavaSQL::Types::BIGINT]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+# frozen-string-literal: true
+
+Sequel::JDBC.load_driver('Java::OracleJdbcDriver::OracleDriver')
+require_relative '../shared/oracle'
+require_relative 'transactions'
+
+module Sequel
+  module JDBC
+    Sequel.synchronize do
+      DATABASE_SETUP[:oracle] = proc do |db|
+        db.extend(Sequel::JDBC::Oracle::DatabaseMethods)
+        db.dataset_class = Sequel::JDBC::Oracle::Dataset
+        Java::OracleJdbcDriver::OracleDriver
+      end
+    end
+
+    module Oracle
+      JAVA_BIG_DECIMAL_CONSTRUCTOR = Java::JavaMath::BigDecimal.java_class.constructor(Java::long).method(:new_instance)
+      ORACLE_DECIMAL = Object.new
+      def ORACLE_DECIMAL.call(r, i)
+        if v = r.getBigDecimal(i)
+          i = v.long_value
+          if v == JAVA_BIG_DECIMAL_CONSTRUCTOR.call(i)
+            i
+          else
+            ::Kernel::BigDecimal(v.to_string)
+          end
+        end
+      end 
+
+      ORACLE_CLOB = Object.new
+      def ORACLE_CLOB.call(r, i)
+        return unless clob = r.getClob(i)
+        str = clob.getSubString(1, clob.length)
+        clob.freeTemporary if clob.isTemporary
+        str
+      end
+
+      module DatabaseMethods
+        include Sequel::Oracle::DatabaseMethods
+        include Sequel::JDBC::Transactions
+
+        def self.extended(db)
+          db.instance_exec do
+            @autosequence = opts[:autosequence]
+            @primary_key_sequences = {}
+          end
+        end
+        
+        private
+
+        # Oracle exception handling with SQLState is less accurate than with regexps.
+        def database_exception_use_sqlstates?
+          false
+        end
+
+        def disconnect_error?(exception, opts)
+          super || exception.message.start_with?("Closed Connection")
+        end
+
+        # Default the fetch size for statements to 100, similar to the oci8-based oracle adapter.
+        def default_fetch_size
+          100
+        end
+        
+        def last_insert_id(conn, opts)
+          unless sequence = opts[:sequence]
+            if t = opts[:table]
+              sequence = sequence_for_table(t)
+            end
+          end
+          if sequence
+            sql = "SELECT #{literal(sequence)}.currval FROM dual"
+            statement(conn) do |stmt|
+              begin
+                rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
+                rs.next
+                rs.getLong(1)
+              rescue Java::JavaSql::SQLException
+                nil
+              end
+            end
+          end
+        end
+
+        # Primary key indexes appear to start with sys_ on Oracle
+        def primary_key_index_re
+          /\Asys_/i
+        end
+
+        def schema_parse_table(*)
+          sch = super
+          sch.each do |c, s|
+            if s[:type] == :decimal && s[:scale] == -127
+              s[:type] = :integer
+            elsif s[:db_type] == 'DATE'
+              s[:type] = :datetime
+            end
+          end
+          sch
+        end
+
+        def schema_parse_table_skip?(h, schema)
+          super || (h[:table_schem] != current_user unless schema)
+        end
+
+        # As of Oracle 9.2, releasing savepoints is no longer supported.
+        def supports_releasing_savepoints?
+          false
+        end
+
+        def setup_type_convertor_map
+          super
+          @type_convertor_map[:OracleDecimal] = ORACLE_DECIMAL
+          @type_convertor_map[:OracleClob] = ORACLE_CLOB
+        end
+      end
+      
+      class Dataset < JDBC::Dataset
+        include Sequel::Oracle::DatasetMethods
+
+        NUMERIC_TYPE = Java::JavaSQL::Types::NUMERIC
+        TIMESTAMP_TYPE = Java::JavaSQL::Types::TIMESTAMP
+        CLOB_TYPE = Java::JavaSQL::Types::CLOB
+        TIMESTAMPTZ_TYPES = [Java::OracleJdbc::OracleTypes::TIMESTAMPTZ, Java::OracleJdbc::OracleTypes::TIMESTAMPLTZ].freeze
+
+        def type_convertor(map, meta, type, i)
+          case type
+          when NUMERIC_TYPE
+            if meta.getScale(i) == 0
+              map[:OracleDecimal]
+            else
+              super
+            end
+          when *TIMESTAMPTZ_TYPES
+            map[TIMESTAMP_TYPE]
+          when CLOB_TYPE 
+            map[:OracleClob]
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end