serrano-vk 0.1.0

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

@@ -0,0 +1,335 @@
+# frozen-string-literal: true
+
+require_relative '../shared/access'
+require_relative '../utils/split_alter_table'
+
+module Sequel
+  module ADO
+    # Database and Dataset instance methods for Access specific
+    # support via ADO.
+    module Access
+      class AdoSchema
+        QUERY_TYPE = {
+          :columns => 4,
+          :indexes => 12,
+          :tables  => 20,
+          :views   => 23,
+          :foreign_keys => 27
+        }.freeze
+        
+        attr_reader :type, :criteria
+
+        def initialize(type, crit)
+          @type     = QUERY_TYPE[type]
+          @criteria = Array(crit)
+        end
+        
+        class Column
+          DATA_TYPE = {
+            2   => "SMALLINT",
+            3   => "INTEGER",
+            4   => "REAL",
+            5   => "DOUBLE",
+            6   => "MONEY",
+            7   => "DATETIME",
+            11  => "BIT",
+            14  => "DECIMAL",
+            16  => "TINYINT",
+            17  => "BYTE",
+            72  => "GUID",
+            128 => "BINARY",
+            130 => "TEXT",
+            131 => "DECIMAL",
+            201 => "TEXT",
+            205 => "IMAGE"
+          }.freeze
+          DATA_TYPE.each_value(&:freeze)
+          
+          def initialize(row)
+            @row = row
+          end
+          
+          def [](col)
+            @row[col]
+          end
+          
+          def allow_null
+            self["IS_NULLABLE"]
+          end
+          
+          def default
+            self["COLUMN_DEFAULT"]
+          end
+          
+          def db_type
+            t = DATA_TYPE[self["DATA_TYPE"]]
+            if t == "DECIMAL" && precision
+              t + "(#{precision.to_i},#{(scale || 0).to_i})"
+            elsif t == "TEXT" && maximum_length && maximum_length > 0
+              t + "(#{maximum_length.to_i})"
+            else
+              t
+            end
+          end
+          
+          def precision
+            self["NUMERIC_PRECISION"]
+          end
+          
+          def scale
+            self["NUMERIC_SCALE"]
+          end
+          
+          def maximum_length
+            self["CHARACTER_MAXIMUM_LENGTH"]
+          end
+        end
+      end      
+
+      module DatabaseMethods
+        include Sequel::Access::DatabaseMethods
+        include Sequel::Database::SplitAlterTable
+    
+        # Remove cached schema after altering a table, since otherwise it can be cached
+        # incorrectly in the rename column case.
+        def alter_table(name, *)
+          super
+          remove_cached_schema(name)
+          nil
+        end
+
+        # Access doesn't let you disconnect if inside a transaction, so
+        # try rolling back an existing transaction first.
+        def disconnect_connection(conn)
+          conn.RollbackTrans rescue nil
+          super
+        end
+
+        def execute_insert(sql, opts=OPTS)
+          synchronize(opts[:server]) do |conn|
+            begin
+              log_connection_yield(sql, conn){conn.Execute(sql)}
+              last_insert_sql = "SELECT @@IDENTITY"
+              res = log_connection_yield(last_insert_sql, conn){conn.Execute(last_insert_sql)}
+              res.GetRows.transpose.each{|r| return r.shift}
+            rescue ::WIN32OLERuntimeError => e
+              raise_error(e)
+            end
+          end
+          nil
+        end
+
+        def tables(opts=OPTS)
+          m = output_identifier_meth
+          ado_schema_tables.map {|tbl| m.call(tbl['TABLE_NAME'])}
+        end
+
+        def views(opts=OPTS)
+          m = output_identifier_meth
+          ado_schema_views.map {|tbl| m.call(tbl['TABLE_NAME'])}
+        end
+        
+        # OpenSchema returns compound indexes as multiple rows
+        def indexes(table_name,opts=OPTS)
+          m = output_identifier_meth
+          idxs = ado_schema_indexes(table_name).inject({}) do |memo, idx|
+            unless idx["PRIMARY_KEY"]
+              index = memo[m.call(idx["INDEX_NAME"])] ||= {
+                :columns=>[], :unique=>idx["UNIQUE"]
+              }
+              index[:columns] << m.call(idx["COLUMN_NAME"])
+            end
+            memo
+          end
+          idxs
+        end
+
+        # OpenSchema returns compound foreign key relationships as multiple rows
+        def foreign_key_list(table, opts=OPTS)
+          m = output_identifier_meth
+          fks = ado_schema_foreign_keys(table).inject({}) do |memo, fk|
+            name = m.call(fk['FK_NAME'])
+            specs = memo[name] ||= {
+              :columns => [],
+              :table   => m.call(fk['PK_TABLE_NAME']),
+              :key     => [],
+              :deferrable => fk['DEFERRABILITY'],
+              :name    => name,
+              :on_delete => fk['DELETE_RULE'],
+              :on_update => fk['UPDATE_RULE']
+            }
+            specs[:columns] << m.call(fk['FK_COLUMN_NAME'])
+            specs[:key]     << m.call(fk['PK_COLUMN_NAME'])
+            memo
+          end
+          fks.values
+        end
+                
+        private
+
+        # Emulate rename_column by adding the column, copying data from the old
+        # column, and dropping the old column.
+        def alter_table_sql(table, op)
+          case op[:op]
+          when :rename_column
+            unless sch = op[:schema]
+              raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]}
+              sch = sch.last
+            end
+            [
+              alter_table_sql(table, :op=>:add_column, :name=>op[:new_name], :default=>sch[:ruby_default], :type=>sch[:db_type], :null=>sch[:allow_null]),
+              from(table).update_sql(op[:new_name]=>op[:name]),
+              alter_table_sql(table, :op=>:drop_column, :name=>op[:name])
+            ]
+          when :set_column_null, :set_column_default
+            raise(Error, "can't find existing schema entry for #{op[:name]}") unless sch = op[:schema] || schema(table).find{|c| c.first == op[:name]}
+            sch = sch.last
+
+            sch = if op[:op] == :set_column_null
+              sch.merge(:allow_null=>op[:null])
+            else
+              sch.merge(:ruby_default=>op[:default])
+            end
+
+            [
+              alter_table_sql(table, :op=>:rename_column, :name=>op[:name], :new_name=>:sequel_access_backup_column, :schema=>sch),
+              alter_table_sql(table, :op=>:rename_column, :new_name=>op[:name], :name=>:sequel_access_backup_column, :schema=>sch)
+            ]
+          else
+            super
+          end
+        end
+
+        def begin_transaction(conn, opts=OPTS)
+          log_connection_yield('Transaction.begin', conn){conn.BeginTrans}
+        end
+          
+        def commit_transaction(conn, opts=OPTS)
+          log_connection_yield('Transaction.commit', conn){conn.CommitTrans}
+        end
+          
+        def rollback_transaction(conn, opts=OPTS)
+          log_connection_yield('Transaction.rollback', conn){conn.RollbackTrans}
+        end
+          
+        def schema_column_type(db_type)
+          case db_type.downcase
+          when 'bit'
+            :boolean
+          when 'byte', 'guid'
+            :integer
+          when 'image'
+            :blob
+          else
+            super
+          end
+        end
+        
+        def schema_parse_table(table_name, opts)
+          m = output_identifier_meth(opts[:dataset])
+          m2 = input_identifier_meth(opts[:dataset])
+          tn = m2.call(table_name.to_s)
+          idxs = ado_schema_indexes(tn)
+          ado_schema_columns(tn).map {|row|
+            specs = { 
+              :allow_null => row.allow_null,
+              :db_type => row.db_type,
+              :default => row.default,
+              :primary_key => !!idxs.find {|idx| 
+                                idx["COLUMN_NAME"] == row["COLUMN_NAME"] &&
+                                idx["PRIMARY_KEY"]
+                              },
+              :type =>  if row.db_type =~ /decimal/i && row.scale == 0
+                          :integer
+                        else
+                          schema_column_type(row.db_type)
+                        end,
+              :ado_type => row["DATA_TYPE"]
+            }
+            specs[:default] = nil if blank_object?(specs[:default])
+            specs[:allow_null] = specs[:allow_null] && !specs[:primary_key]
+            [ m.call(row["COLUMN_NAME"]), specs ]
+          }
+        end
+
+        def ado_schema_tables
+          rows=[]
+          fetch_ado_schema(:tables, [nil,nil,nil,'TABLE']) do |row|
+            rows << row
+          end
+          rows
+        end
+
+        def ado_schema_views
+          rows=[]
+          fetch_ado_schema(:views, [nil,nil,nil]) do |row|
+            rows << row
+          end
+          rows
+        end
+        
+        def ado_schema_indexes(table_name)
+          rows=[]
+          fetch_ado_schema(:indexes, [nil,nil,nil,nil,table_name.to_s]) do |row|
+            rows << row
+          end
+          rows
+        end
+        
+        def ado_schema_columns(table_name)
+          rows=[]
+          fetch_ado_schema(:columns, [nil,nil,table_name.to_s,nil]) do |row| 
+            rows << AdoSchema::Column.new(row)
+          end
+          rows.sort_by! { |a| a["ORDINAL_POSITION"] }
+        end
+        
+        def ado_schema_foreign_keys(table_name)
+          rows=[]
+          fetch_ado_schema(:foreign_keys, [nil,nil,nil,nil,nil,table_name.to_s]) do |row| 
+            rows << row
+          end
+          rows.sort_by! { |a| a["ORDINAL"] }
+        end
+        
+        def fetch_ado_schema(type, criteria=[])
+          execute_open_ado_schema(type, criteria) do |s|
+            cols = []
+            s.Fields.each{|f| cols << f.Name}
+            s.GetRows.transpose.each do |r|
+              row = {}
+              cols.each{|c| row[c] = r.shift}
+              yield row
+            end unless s.eof
+          end
+        end
+             
+        # This is like execute() in that it yields an ADO RecordSet, except
+        # instead of an SQL interface there's this OpenSchema call
+        # cf. http://msdn.microsoft.com/en-us/library/ee275721(v=bts.10)
+        def execute_open_ado_schema(type, criteria=[])
+          ado_schema = AdoSchema.new(type, criteria)
+          synchronize(opts[:server]) do |conn|
+            begin
+              r = log_connection_yield("OpenSchema #{type.inspect}, #{criteria.inspect}", conn) { 
+                if ado_schema.criteria.empty?
+                  conn.OpenSchema(ado_schema.type) 
+                else
+                  conn.OpenSchema(ado_schema.type, ado_schema.criteria) 
+                end
+              }
+              yield(r) if defined?(yield)
+            rescue ::WIN32OLERuntimeError => e
+              raise_error(e)
+            end
+          end
+          nil
+        end
+      end
+      
+      class Dataset < ADO::Dataset
+        include Sequel::Access::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen-string-literal: true
+
+require_relative '../shared/mssql'
+
+module Sequel
+  module ADO
+    module MSSQL
+      module DatabaseMethods
+        include Sequel::MSSQL::DatabaseMethods
+
+        def execute_dui(sql, opts=OPTS)
+          return super unless @opts[:provider]
+          synchronize(opts[:server]) do |conn|
+            begin
+              sql = "SET NOCOUNT ON; #{sql}; SELECT @@ROWCOUNT"
+              rst = log_connection_yield(sql, conn){conn.Execute(sql)}
+              rst.GetRows[0][0]
+            rescue ::WIN32OLERuntimeError => e
+              raise_error(e)
+            end
+          end
+        end
+
+        private
+
+        # The ADO adapter's default provider doesn't support transactions, since it 
+        # creates a new native connection for each query.  So Sequel only attempts
+        # to use transactions if an explicit :provider is given.
+        def begin_transaction(conn, opts=OPTS)
+          super if @opts[:provider]
+        end
+
+        def commit_transaction(conn, opts=OPTS)
+          super if @opts[:provider]
+        end
+
+        def rollback_transaction(conn, opts=OPTS)
+          super if @opts[:provider]
+        end
+      end
+      
+      class Dataset < ADO::Dataset
+        include Sequel::MSSQL::DatasetMethods
+
+        # Use a nasty hack of multiple SQL statements in the same call and
+        # having the last one return the most recently inserted id.  This
+        # is necessary as ADO's default :provider uses a separate native
+        # connection for each query.
+        def insert(*values)
+          return super if (@opts[:sql] && !@opts[:prepared_sql]) || @opts[:returning]
+          with_sql("SET NOCOUNT ON; #{insert_sql(*values)}; SELECT CAST(SCOPE_IDENTITY() AS INTEGER)").single_value
+        end
+        
+        # If you use a better :provider option for the database, you can get an
+        # accurate number of rows matched.
+        def provides_accurate_rows_matched?
+          !!db.opts[:provider]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,283 @@
+# frozen-string-literal: true
+
+require 'win32ole'
+
+module Sequel
+  # The ADO adapter provides connectivity to ADO databases in Windows.
+  module ADO
+    # ADO constants (DataTypeEnum)
+    # Source: https://msdn.microsoft.com/en-us/library/ms675318(v=vs.85).aspx
+    AdBigInt           = 20
+    AdBinary           = 128
+    #AdBoolean          = 11
+    #AdBSTR             = 8
+    #AdChapter          = 136
+    #AdChar             = 129
+    #AdCurrency         = 6
+    #AdDate             = 7
+    AdDBDate           = 133
+    #AdDBTime           = 134
+    AdDBTimeStamp      = 135
+    #AdDecimal          = 14
+    #AdDouble           = 5
+    #AdEmpty            = 0
+    #AdError            = 10
+    #AdFileTime         = 64
+    #AdGUID             = 72
+    #AdIDispatch        = 9
+    #AdInteger          = 3
+    #AdIUnknown         = 13
+    AdLongVarBinary    = 205
+    #AdLongVarChar      = 201
+    #AdLongVarWChar     = 203
+    AdNumeric          = 131
+    #AdPropVariant      = 138
+    #AdSingle           = 4
+    #AdSmallInt         = 2
+    #AdTinyInt          = 16
+    #AdUnsignedBigInt   = 21
+    #AdUnsignedInt      = 19
+    #AdUnsignedSmallInt = 18
+    #AdUnsignedTinyInt  = 17
+    #AdUserDefined      = 132
+    AdVarBinary        = 204
+    #AdVarChar          = 200
+    #AdVariant          = 12
+    AdVarNumeric       = 139
+    #AdVarWChar         = 202
+    #AdWChar            = 130
+
+    bigint = Object.new
+    def bigint.call(v)
+      v.to_i
+    end
+
+    numeric = Object.new
+    def numeric.call(v)
+      if v.include?(',')
+        BigDecimal(v.tr(',', '.'))
+      else
+        BigDecimal(v)
+      end
+    end
+
+    binary = Object.new
+    def binary.call(v)
+      Sequel.blob(v.pack('c*'))
+    end
+
+    date = Object.new
+    def date.call(v)
+      Date.new(v.year, v.month, v.day)
+    end
+
+    CONVERSION_PROCS = {}
+    [
+      [bigint, AdBigInt],
+      [numeric, AdNumeric, AdVarNumeric],
+      [date, AdDBDate],
+      [binary, AdBinary, AdVarBinary, AdLongVarBinary]
+    ].each do |callable, *types|
+      callable.freeze
+      types.each do |i|
+        CONVERSION_PROCS[i] = callable
+      end
+    end
+    CONVERSION_PROCS.freeze
+
+    class Database < Sequel::Database
+      set_adapter_scheme :ado
+
+      attr_reader :conversion_procs
+
+      # In addition to the usual database options,
+      # the following options have an effect:
+      #
+      # :command_timeout :: Sets the time in seconds to wait while attempting
+      #                     to execute a command before cancelling the attempt and generating
+      #                     an error. Specifically, it sets the ADO CommandTimeout property.
+      # :driver :: The driver to use in the ADO connection string.  If not provided, a default
+      #            of "SQL Server" is used.
+      # :conn_string :: The full ADO connection string.  If this is provided,
+      #                 the usual options are ignored.
+      # :provider :: Sets the Provider of this ADO connection (for example, "SQLOLEDB").
+      #              If you don't specify a provider, the default one used by WIN32OLE
+      #              has major problems, such as creating a new native database connection
+      #              for every query, which breaks things such as temporary tables.
+      #
+      # Pay special attention to the :provider option, as without specifying a provider,
+      # many things will be broken.  The SQLNCLI10 provider appears to work well if you
+      # are connecting to Microsoft SQL Server, but it is not the default as that is not
+      # always available and would break backwards compatability.
+      def connect(server)
+        opts = server_opts(server)
+        s = opts[:conn_string] || "driver=#{opts[:driver]};server=#{opts[:host]};database=#{opts[:database]}#{";uid=#{opts[:user]};pwd=#{opts[:password]}" if opts[:user]}"
+        handle = WIN32OLE.new('ADODB.Connection')
+        handle.CommandTimeout = opts[:command_timeout] if opts[:command_timeout]
+        handle.Provider = opts[:provider] if opts[:provider]
+        handle.Open(s)
+        handle
+      end
+      
+      def disconnect_connection(conn)
+        conn.Close
+      rescue WIN32OLERuntimeError
+        nil
+      end
+
+      def freeze
+        @conversion_procs.freeze
+        super
+      end
+
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_ddl(sql, opts=OPTS)
+        execute(sql, opts)
+      end
+
+      # Just execute so it doesn't attempt to return the number of rows modified.
+      def execute_insert(sql, opts=OPTS)
+        execute(sql, opts)
+      end
+      
+      # Use pass by reference in WIN32OLE to get the number of affected rows,
+      # unless is a provider is in use (since some providers don't seem to
+      # return the number of affected rows, but the default provider appears
+      # to).
+      def execute_dui(sql, opts=OPTS)
+        return super if opts[:provider]
+        synchronize(opts[:server]) do |conn|
+          begin
+            log_connection_yield(sql, conn){conn.Execute(sql, 1)}
+            WIN32OLE::ARGV[1]
+          rescue ::WIN32OLERuntimeError => e
+            raise_error(e)
+          end
+        end
+      end
+
+      def execute(sql, opts=OPTS)
+        synchronize(opts[:server]) do |conn|
+          begin
+            r = log_connection_yield(sql, conn){conn.Execute(sql)}
+            begin
+              yield r if defined?(yield)
+            ensure
+              begin
+                r.close
+              rescue ::WIN32OLERuntimeError
+              end
+            end
+          rescue ::WIN32OLERuntimeError => e
+            raise_error(e)
+          end
+        end
+        nil
+      end
+
+      private
+      
+      def adapter_initialize
+        case @opts[:conn_string]
+        when /Microsoft\.(Jet|ACE)\.OLEDB/i
+          require_relative 'ado/access'
+          extend Sequel::ADO::Access::DatabaseMethods
+          self.dataset_class = ADO::Access::Dataset
+        else
+          @opts[:driver] ||= 'SQL Server'
+          case @opts[:driver]
+          when 'SQL Server'
+            require_relative 'ado/mssql'
+            extend Sequel::ADO::MSSQL::DatabaseMethods
+            self.dataset_class = ADO::MSSQL::Dataset
+            set_mssql_unicode_strings
+          end
+        end
+
+        @conversion_procs = CONVERSION_PROCS.dup
+        @conversion_procs[AdDBTimeStamp] = method(:adb_timestamp_to_application_timestamp)
+
+        super
+      end
+
+      def adb_timestamp_to_application_timestamp(v)
+        # This hard codes a timestamp_precision of 6 when converting.
+        # That is the default timestamp_precision, but the ado/mssql adapter uses a timestamp_precision
+        # of 3.  However, timestamps returned by ado/mssql have nsec values that end up rounding to a
+        # the same value as if a timestamp_precision of 3 was hard coded (either xxx999yzz, where y is
+        # 5-9 or xxx000yzz where y is 0-4).
+        #
+        # ADO subadapters should override this they would like a different timestamp precision and the
+        # this code does not work for them (for example, if they provide full nsec precision).
+        #
+        # Note that fractional second handling for WIN32OLE objects is not correct on ruby <2.2
+        to_application_timestamp([v.year, v.month, v.day, v.hour, v.min, v.sec, (v.nsec/1000.0).round * 1000])
+      end
+
+      def dataset_class_default
+        Dataset
+      end
+
+      # The ADO adapter's default provider doesn't support transactions, since it 
+      # creates a new native connection for each query.  So Sequel only attempts
+      # to use transactions if an explicit :provider is given.
+      def begin_transaction(conn, opts=OPTS)
+        super if @opts[:provider]
+      end
+
+      def commit_transaction(conn, opts=OPTS)
+        super if @opts[:provider]
+      end
+
+      def database_error_classes
+        [::WIN32OLERuntimeError]
+      end
+
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::WIN32OLERuntimeError) && e.message.include?('Communication link failure'))
+      end
+
+      def rollback_transaction(conn, opts=OPTS)
+        super if @opts[:provider]
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      def fetch_rows(sql)
+        execute(sql) do |recordset|
+          cols = []
+          conversion_procs = db.conversion_procs
+
+          recordset.Fields.each do |field|
+            cols << [output_identifier(field.Name), conversion_procs[field.Type]]
+          end
+
+          self.columns = cols.map(&:first)
+          return if recordset.EOF
+          max = cols.length
+
+          recordset.GetRows.transpose.each do |field_values|
+            h = {}
+
+            i = -1
+            while (i += 1) < max
+              name, cp = cols[i]
+              h[name] = if (v = field_values[i]) && cp
+                cp.call(v)
+              else
+                v
+              end
+            end
+            
+            yield h
+          end
+        end
+      end
+      
+      # ADO can return for for delete and update statements, depending on the provider.
+      def provides_accurate_rows_matched?
+        false
+      end
+    end
+  end
+end