tdiary 5.0.1 → 5.0.2

data/vendor/bundle/gems/sequel-4.37.0/lib/sequel/adapters/swift.rb

@@ -0,0 +1,162 @@
+# frozen-string-literal: true
+
+module Sequel
+  # Module holding the Swift DB support for Sequel.  Swift DB is a
+  # collection of drivers used in Swift ORM.
+  #
+  # The Swift adapter currently supports PostgreSQL, MySQL and SQLite3
+  #
+  #   Sequel.connect('swift://user:password@host/database?db_type=postgres')
+  #   Sequel.connect('swift://user:password@host/database?db_type=mysql')
+  module Swift
+    # Contains procs keyed on sub adapter type that extend the
+    # given database object so it supports the correct database type.
+    DATABASE_SETUP = {:postgres=>proc do |db|
+        db.extend(Sequel::Swift::Postgres::DatabaseMethods)
+        db.extend_datasets Sequel::Postgres::DatasetMethods
+        db.swift_class = ::Swift::DB::Postgres
+      end,
+      :mysql=>proc do |db|
+        db.extend(Sequel::Swift::MySQL::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::MySQL::Dataset
+        db.swift_class = ::Swift::DB::Mysql
+      end,
+      :sqlite=>proc do |db|
+        db.extend(Sequel::Swift::SQLite::DatabaseMethods)
+        db.dataset_class = Sequel::Swift::SQLite::Dataset
+        db.swift_class = ::Swift::DB::Sqlite3
+        db.set_integer_booleans
+      end,
+    }
+      
+    class Database < Sequel::Database
+      set_adapter_scheme :swift
+
+      # The Swift adapter class being used by this database.  Connections
+      # in this database's connection pool will be instances of this class.
+      attr_accessor :swift_class
+
+      def initialize(opts=OPTS)
+        Sequel.require "adapters/swift/#{opts[:db_type]}" if %w'postgres mysql sqlite'.include?(opts[:db_type].to_s)
+        super
+      end
+      
+      # Create an instance of swift_class for the given options.
+      def connect(server)
+        opts = server_opts(server)
+        opts[:pass] = opts[:password]
+        setup_connection(swift_class.new(opts))
+      end
+      
+      # Execute the given SQL, yielding a Swift::Result if a block is given.
+      def execute(sql, opts=OPTS)
+        synchronize(opts[:server]) do |conn|
+          begin
+            res = log_connection_yield(sql, conn){conn.execute(sql)}
+            yield res if block_given?
+            nil
+          rescue ::Swift::Error => e
+            raise_error(e)
+          end
+        end
+      end
+      
+      # Execute the SQL on the this database, returning the number of affected
+      # rows.
+      def execute_dui(sql, opts=OPTS)
+        synchronize(opts[:server]) do |conn|
+          begin
+            log_connection_yield(sql, conn){conn.execute(sql).affected_rows}
+          rescue ::Swift::Error => e
+            raise_error(e)
+          end
+        end
+      end
+      
+      # Execute the SQL on this database, returning the primary key of the
+      # table being inserted to.
+      def execute_insert(sql, opts=OPTS)
+        synchronize(opts[:server]) do |conn|
+          begin
+            log_connection_yield(sql, conn){conn.execute(sql).insert_id}
+          rescue ::Swift::Error => e
+            raise_error(e)
+          end
+        end
+      end
+      
+      private
+      
+      # Call the DATABASE_SETUP proc directly after initialization,
+      # so the object always uses sub adapter specific code.  Also,
+      # raise an error immediately if the connection doesn't have a
+      # db_type specified, since one is required to include the correct
+      # subadapter.
+      def adapter_initialize
+        if db_type = @opts[:db_type] and !db_type.to_s.empty? 
+          if prok = DATABASE_SETUP[db_type.to_s.to_sym]
+            prok.call(self)
+          else
+            raise(Error, "No :db_type option specified")
+          end
+        else
+          raise(Error, ":db_type option not valid, should be postgres, mysql, or sqlite")
+        end
+      end
+      
+      # Method to call on a statement object to execute SQL that does
+      # not return any rows.
+      def connection_execute_method
+        :execute
+      end
+      
+      def database_error_classes
+        [::Swift::Error]
+      end
+
+      # Set the :db entry to the same as the :database entry, since
+      # Swift uses :db.
+      def server_opts(o)
+        o = super
+        o[:db] ||= o[:database]
+        o
+      end
+      
+      # Allow extending the given connection when it is first created.
+      # By default, just returns the connection.
+      def setup_connection(conn)
+        conn
+      end
+    end
+    
+    class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+
+      # Set the columns and yield the hashes to the block.
+      def fetch_rows(sql)
+        execute(sql) do |res|
+          col_map = {}
+          self.columns = res.fields.map do |c|
+            col_map[c] = output_identifier(c)
+          end
+          tz = db.timezone if Sequel.application_timezone
+          res.each do |r|
+            h = {}
+            r.each do |k, v|
+              h[col_map[k]] = case v
+              when StringIO
+                SQL::Blob.new(v.read)
+              when DateTime
+                tz ? Sequel.database_to_application_timestamp(Sequel.send(:convert_input_datetime_no_offset, v, tz)) : v
+              else
+                v
+              end
+            end
+            yield h
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sequel-4.37.0/lib/sequel/adapters/utils/mysql_mysql2.rb

@@ -0,0 +1,82 @@
+# frozen-string-literal: true
+
+Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+
+module Sequel
+  module MySQL
+    # This module is used by the mysql and mysql2 adapters to support
+    # prepared statements and stored procedures.
+    module MysqlMysql2
+      module DatabaseMethods
+        disconnect_errors = <<-END.split("\n").map(&:strip)
+        Commands out of sync; you can't run this command now
+        Can't connect to local MySQL server through socket
+        MySQL server has gone away
+        Lost connection to MySQL server during query
+        This connection is still waiting for a result, try again once you have the result
+        closed MySQL connection
+        END
+        # Error messages for mysql and mysql2 that indicate the current connection should be disconnected
+        MYSQL_DATABASE_DISCONNECT_ERRORS = /\A#{Regexp.union(disconnect_errors)}/o
+       
+        # Support stored procedures on MySQL
+        def call_sproc(name, opts=OPTS, &block)
+          args = opts[:args] || [] 
+          execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
+        end
+        
+        # Executes the given SQL using an available connection, yielding the
+        # connection if the block is given.
+        def execute(sql, opts=OPTS, &block)
+          if opts[:sproc]
+            call_sproc(sql, opts, &block)
+          elsif sql.is_a?(Symbol)
+            execute_prepared_statement(sql, opts, &block)
+          else
+            synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
+          end
+        end
+        
+        private
+
+        def add_prepared_statements_cache(conn)
+          class << conn
+            attr_accessor :prepared_statements
+          end
+          conn.prepared_statements = {}
+        end
+
+        # Stupid MySQL doesn't use SQLState error codes correctly, mapping
+        # all constraint violations to 23000 even though it recognizes
+        # different types.
+        def database_specific_error_class(exception, opts)
+          case exception.errno
+          when 1048
+            NotNullConstraintViolation
+          when 1062
+            UniqueConstraintViolation
+          when 1451, 1452
+            ForeignKeyConstraintViolation
+          else
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        include Sequel::Dataset::StoredProcedures
+       
+        StoredProcedureMethods = Sequel::Dataset.send(:prepared_statements_module,
+          "sql = @sproc_name; opts = Hash[opts]; opts[:args] = @sproc_args; opts[:sproc] = true",
+          Sequel::Dataset::StoredProcedureMethods, %w'execute execute_dui')
+        
+        private
+
+        # Extend the dataset with the MySQL stored procedure methods.
+        def prepare_extend_sproc(ds)
+          ds.extend(StoredProcedureMethods)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sequel-4.37.0/lib/sequel/adapters/utils/mysql_prepared_statements.rb

@@ -0,0 +1,82 @@
+# frozen-string-literal: true
+
+module Sequel
+  module MySQL
+    module PreparedStatements
+      module DatabaseMethods
+        private
+
+        # Executes a prepared statement on an available connection.  If the
+        # prepared statement already exists for the connection and has the same
+        # SQL, reuse it, otherwise, prepare the new statement.  Because of the
+        # usual MySQL stupidity, we are forced to name arguments via separate
+        # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
+        # arguments.
+        def execute_prepared_statement(ps_name, opts, &block)
+          args = opts[:arguments]
+          ps = prepared_statement(ps_name)
+          sql = ps.prepared_sql
+          synchronize(opts[:server]) do |conn|
+            unless conn.prepared_statements[ps_name] == sql
+              _execute(conn, "PREPARE #{ps_name} FROM #{literal(sql)}", opts)
+              conn.prepared_statements[ps_name] = sql
+            end
+            i = 0
+            _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
+            opts = opts.merge(:log_sql=>" (#{sql})") if ps.log_sql
+            _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
+          end
+        end
+      end
+
+      module DatasetMethods
+        # Methods to add to MySQL prepared statement calls without using a
+        # real database prepared statement and bound variables.
+        module CallableStatementMethods
+          # Extend given dataset with this module so subselects inside subselects in
+          # prepared statements work.
+          def subselect_sql_append(sql, ds)
+            ps = ds.to_prepared_statement(:select).clone(:append_sql => sql)
+            ps.extend(CallableStatementMethods)
+            ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
+            ps.prepared_args = prepared_args
+            ps.prepared_sql
+          end
+        end
+        
+        PreparedStatementMethods = Sequel::Dataset.send(:prepared_statements_module,
+          :prepare_bind,
+          Sequel::Dataset::UnnumberedArgumentMapper) do
+            # Raise a more obvious error if you attempt to call a unnamed prepared statement.
+            def call(*)
+              raise Error, "Cannot call prepared statement without a name" if prepared_statement_name.nil?
+              super
+            end
+        end
+        
+        # MySQL is different in that it supports prepared statements but not bound
+        # variables outside of prepared statements.  The default implementation
+        # breaks the use of subselects in prepared statements, so extend the
+        # temporary prepared statement that this creates with a module that
+        # fixes it.
+        def call(type, bind_arguments={}, *values, &block)
+          ps = to_prepared_statement(type, values)
+          ps.extend(CallableStatementMethods)
+          ps.call(bind_arguments, &block)
+        end
+        
+        # Store the given type of prepared statement in the associated database
+        # with the given name.
+        def prepare(type, name=nil, *values)
+          ps = to_prepared_statement(type, values)
+          ps.extend(PreparedStatementMethods)
+          if name
+            ps.prepared_statement_name = name
+            db.set_prepared_statement(name, ps)
+          end
+          ps
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sequel-4.37.0/lib/sequel/ast_transformer.rb

@@ -0,0 +1,208 @@
+# frozen-string-literal: true
+
+module Sequel
+  # The +ASTTransformer+ class is designed to handle the abstract syntax trees
+  # that Sequel uses internally and produce modified copies of them.  By itself
+  # it only produces a straight copy.  It's designed to be subclassed and have
+  # subclasses returned modified copies of the specific nodes that need to
+  # be modified.
+  class ASTTransformer
+    # Return +obj+ or a potentially transformed version of it.
+    def transform(obj)
+      v(obj)
+    end
+
+    private
+
+    # Recursive version that handles all of Sequel's internal object types
+    # and produces copies of them.
+    def v(o)
+      case o
+      when Symbol, Numeric, String, Class, TrueClass, FalseClass, NilClass
+        o
+      when Array
+        o.map{|x| v(x)}
+      when Hash
+        h = {}
+        o.each{|k, val| h[v(k)] = v(val)}
+        h
+      when SQL::NumericExpression
+        if o.op == :extract
+          o.class.new(o.op, o.args[0], v(o.args[1]))
+        else
+          o.class.new(o.op, *v(o.args))
+        end
+      when SQL::ComplexExpression
+        o.class.new(o.op, *v(o.args))
+      when SQL::Identifier
+        SQL::Identifier.new(v(o.value))
+      when SQL::QualifiedIdentifier
+        SQL::QualifiedIdentifier.new(v(o.table), v(o.column))
+      when SQL::OrderedExpression
+        SQL::OrderedExpression.new(v(o.expression), o.descending, :nulls=>o.nulls)
+      when SQL::AliasedExpression
+        SQL::AliasedExpression.new(v(o.expression), o.alias, o.columns)
+      when SQL::CaseExpression
+        args = [v(o.conditions), v(o.default)]
+        args << v(o.expression) if o.expression?
+        SQL::CaseExpression.new(*args)
+      when SQL::Cast
+        SQL::Cast.new(v(o.expr), o.type)
+      when SQL::Function
+        h = {}
+        o.opts.each do |k, val|
+          h[k] = v(val)
+        end
+        SQL::Function.new!(o.name, v(o.args), h)
+      when SQL::Subscript
+        SQL::Subscript.new(v(o.f), v(o.sub))
+      when SQL::Window
+        opts = o.opts.dup
+        opts[:partition] = v(opts[:partition]) if opts[:partition]
+        opts[:order] = v(opts[:order]) if opts[:order]
+        SQL::Window.new(opts)
+      when SQL::PlaceholderLiteralString
+        args = if o.args.is_a?(Hash)
+          h = {}
+          o.args.each{|k,val| h[k] = v(val)}
+          h
+        else
+          v(o.args)
+        end
+        SQL::PlaceholderLiteralString.new(o.str, args, o.parens)
+      when SQL::JoinOnClause
+        SQL::JoinOnClause.new(v(o.on), o.join_type, v(o.table_expr))
+      when SQL::JoinUsingClause
+        SQL::JoinUsingClause.new(v(o.using), o.join_type, v(o.table_expr))
+      when SQL::JoinClause
+        SQL::JoinClause.new(o.join_type, v(o.table_expr))
+      when SQL::DelayedEvaluation
+        SQL::DelayedEvaluation.new(lambda{|ds| v(o.call(ds))})
+      when SQL::Wrapper
+        SQL::Wrapper.new(v(o.value))
+      else
+        o
+      end
+    end
+  end
+
+  # Handles qualifying existing datasets, so that unqualified columns
+  # in the dataset are qualified with a given table name.
+  class Qualifier < ASTTransformer
+    # Store the dataset to use as the basis for qualification, 
+    # and the table used to qualify unqualified columns. 
+    def initialize(ds, table)
+      @ds = ds
+      @table = table
+    end
+
+    private
+
+    # Turn <tt>SQL::Identifier</tt>s and symbols that aren't implicitly
+    # qualified into <tt>SQL::QualifiedIdentifier</tt>s.  For symbols that
+    # are not implicitly qualified by are implicitly aliased, return an
+    # <tt>SQL::AliasedExpression</tt>s with a qualified version of the symbol.
+    def v(o)
+      case o
+      when Symbol
+        t, column, aliaz = @ds.send(:split_symbol, o)
+        if t
+          o
+        elsif aliaz
+          SQL::AliasedExpression.new(SQL::QualifiedIdentifier.new(@table, SQL::Identifier.new(column)), aliaz)
+        else
+          SQL::QualifiedIdentifier.new(@table, o)
+        end
+      when SQL::Identifier
+        SQL::QualifiedIdentifier.new(@table, o)
+      when SQL::QualifiedIdentifier, SQL::JoinClause
+        # Return these directly, so we don't accidentally qualify symbols in them.
+        o
+      else
+        super
+      end
+    end
+  end
+
+  # +Unbinder+ is used to take a dataset filter and return a modified version
+  # that unbinds already bound values and returns a dataset with bound value
+  # placeholders and a hash of bind values.  You can then prepare the dataset
+  # and use the bound variables to execute it with the same values.
+  #
+  # This class only does a limited form of unbinding where the variable names
+  # and values can be associated unambiguously.  The only cases it handles
+  # are <tt>SQL::ComplexExpression<tt> with an operator in +UNBIND_OPS+, a
+  # first argument that's an instance of a member of +UNBIND_KEY_CLASSES+, and
+  # a second argument that's an instance of a member of +UNBIND_VALUE_CLASSES+.
+  #
+  # So it can handle cases like:
+  #
+  #   DB.filter(:a=>1).exclude(:b=>2).where{c > 3}
+  #
+  # But it cannot handle cases like:
+  #
+  #   DB.filter(:a + 1 < 0)
+  class Unbinder < ASTTransformer
+    # The <tt>SQL::ComplexExpression<tt> operates that will be considered
+    # for transformation.
+    UNBIND_OPS = [:'=', :'!=', :<, :>, :<=, :>=]
+
+    # The key classes (first argument of the ComplexExpression) that will
+    # considered for transformation.
+    UNBIND_KEY_CLASSES = [Symbol, SQL::Identifier, SQL::QualifiedIdentifier]
+
+    # The value classes (second argument of the ComplexExpression) that
+    # will be considered for transformation.
+    UNBIND_VALUE_CLASSES = [Numeric, String, Date, Time]
+
+    # The hash of bind variables that were extracted from the dataset filter.
+    attr_reader :binds
+
+    # Intialize an empty +binds+ hash.
+    def initialize
+      @binds = {}
+    end
+
+    private
+
+    # Create a suitable bound variable key for the object, which should be
+    # an instance of one of the +UNBIND_KEY_CLASSES+.
+    def bind_key(obj)
+      case obj
+      when Symbol
+        obj
+      when String
+        obj.to_sym
+      when SQL::Identifier
+        bind_key(obj.value)
+      when SQL::QualifiedIdentifier
+        :"#{bind_key(obj.table)}.#{bind_key(obj.column)}"
+      else
+        raise Error, "unhandled object in Sequel::Unbinder#bind_key: #{obj}"
+      end
+    end
+
+    # Handle <tt>SQL::ComplexExpression</tt> instances with suitable ops
+    # and arguments, substituting the value with a bound variable placeholder
+    # and assigning it an entry in the +binds+ hash with a matching key.
+    def v(o)
+      if o.is_a?(SQL::ComplexExpression) && UNBIND_OPS.include?(o.op)
+        l, r = o.args
+        l = l.value if l.is_a?(Sequel::SQL::Wrapper)
+        r = r.value if r.is_a?(Sequel::SQL::Wrapper)
+        if UNBIND_KEY_CLASSES.any?{|c| l.is_a?(c)} && UNBIND_VALUE_CLASSES.any?{|c| r.is_a?(c)} && !r.is_a?(LiteralString)
+          key = bind_key(l)
+          if (old = binds[key]) && old != r
+            raise UnbindDuplicate, "two different values for #{key.inspect}: #{[r, old].inspect}" 
+          end
+          binds[key] = r
+          SQL::ComplexExpression.new(o.op, l, :"$#{key}")
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+  end
+end

data/vendor/bundle/gems/sequel-4.37.0/lib/sequel/connection_pool/sharded_single.rb

@@ -0,0 +1,110 @@
+# frozen-string-literal: true
+
+# A ShardedSingleConnectionPool is a single threaded connection pool that
+# works with multiple shards/servers.
+class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
+  # The single threaded pool takes the following options:
+  #
+  # :servers :: A hash of servers to use.  Keys should be symbols.  If not
+  #             present, will use a single :default server.
+  # :servers_hash :: The base hash to use for the servers.  By default,
+  #                  Sequel uses Hash.new(:default).  You can use a hash with a default proc
+  #                  that raises an error if you want to catch all cases where a nonexistent
+  #                  server is used.
+  def initialize(db, opts=OPTS)
+    super
+    @conns = {}
+    @servers = opts.fetch(:servers_hash, Hash.new(:default))
+    add_servers([:default])
+    add_servers(opts[:servers].keys) if opts[:servers]
+  end
+  
+  # Adds new servers to the connection pool. Primarily used in conjunction with master/slave
+  # or shard configurations. Allows for dynamic expansion of the potential slaves/shards
+  # at runtime. servers argument should be an array of symbols. 
+  def add_servers(servers)
+    servers.each{|s| @servers[s] = s}
+  end
+
+  # Yield all of the currently established connections
+  def all_connections
+    @conns.values.each{|c| yield c}
+  end
+  
+  # The connection for the given server.
+  def conn(server=:default)
+    @conns[@servers[server]]
+  end
+  
+  # Disconnects from the database. Once a connection is requested using
+  # #hold, the connection is reestablished. Options:
+  # :server :: Should be a symbol specifing the server to disconnect from,
+  #            or an array of symbols to specify multiple servers.
+  def disconnect(opts=OPTS)
+    (opts[:server] ? Array(opts[:server]) : servers).each{|s| disconnect_server(s)}
+  end
+  
+  # Yields the connection to the supplied block for the given server.
+  # This method simulates the ConnectionPool#hold API.
+  def hold(server=:default)
+    begin
+      server = pick_server(server)
+      yield(@conns[server] ||= make_new(server))
+    rescue Sequel::DatabaseDisconnectError, *@error_classes => e
+      disconnect_server(server) if disconnect_error?(e)
+      raise
+    end
+  end
+  
+  # The ShardedSingleConnectionPool always has a maximum size of 1.
+  def max_size
+    1
+  end
+  
+  # Remove servers from the connection pool. Primarily used in conjunction with master/slave
+  # or shard configurations.  Similar to disconnecting from all given servers,
+  # except that after it is used, future requests for the server will use the
+  # :default server instead.
+  def remove_servers(servers)
+    raise(Sequel::Error, "cannot remove default server") if servers.include?(:default)
+    servers.each do |server|
+      disconnect_server(server)
+      @servers.delete(server)
+    end
+  end
+  
+  # Return an array of symbols for servers in the connection pool.
+  def servers
+    @servers.keys
+  end
+  
+  # The number of different shards/servers this pool is connected to.
+  def size
+    @conns.length
+  end
+  
+  def pool_type
+    :sharded_single
+  end
+  
+  private
+  
+  # Disconnect from the given server, if connected.
+  def disconnect_server(server)
+    if conn = @conns.delete(server)
+      disconnect_connection(conn)
+    end
+  end
+
+  # If the server given is in the hash, return it, otherwise, return the default server.
+  def pick_server(server)
+    @servers[server]
+  end
+  
+  # Make sure there is a valid connection for each server.
+  def preconnect(concurrent = nil)
+    servers.each{|s| hold(s){}}
+  end
+  
+  CONNECTION_POOL_MAP[[true, true]] = self
+end