edgeway 0.1.0 → 0.2.0

data/lib/edgeway/model/attributes.rb

@@ -8,16 +8,33 @@ module Edgeway
     INT_MAX = 2147483647
     INT_MIN = -2147483648
 
+    PRIMARY = "primary"
+
+    def self.registry = (@registry ||= ConnectionRegistry.new)
+
+    def self.connect(name, adapter) = registry.connect(name, adapter)
+
+    def self.disconnect(name) = registry.disconnect(name)
+
     def self.connection=(adapter)
-      @connection = adapter
+      connect(PRIMARY, adapter)
     end
 
-    def self.connection
-      @connection || raise(ConfigurationError, "Edgeway::Model.connection is not set")
+    def self.connected? = registry.connected?(PRIMARY)
+
+    def self.connection = connection_for(PRIMARY)
+
+    def self.connection_for(name) = registry.fetch(name)
+
+    def self.database_names = registry.names
+
+    def self.query_stats(name = PRIMARY)
+      connection_for(name).query_stats
     end
 
     # Runs the block with writes queued instead of executed, then sends them
-    # all as one atomic batch (D1 batch(): one SQL transaction, all or none).
+    # all as one atomic batch (one SQL transaction, all or none).
+    # A batch belongs to the database of its first write.
     def self.batch
       if @batch_queue
         yield
@@ -25,14 +42,16 @@ module Edgeway
       end
       queue = []
       @batch_queue = queue
+      @batch_database = nil
       begin
         yield
       rescue => e
         @batch_queue = nil
         raise e
       end
+      database = @batch_database
       @batch_queue = nil
-      queue.empty? ? [] : connection.batch(queue)
+      queue.empty? ? [] : connection_for(database).batch(queue)
     end
 
     def self.batching? = !@batch_queue.nil?
@@ -40,16 +59,42 @@ module Edgeway
     # Every model write but an INSERT goes through here: executed at once, or
     # queued inside batch. A queued write answers a placeholder result, as its
     # counts are not known until the batch is sent.
-    def self.write(sql, binds)
+    def self.write(sql, binds, database: PRIMARY)
+      name = database.to_s
       queue = @batch_queue
       if queue.nil?
-        connection.execute(sql, binds)
+        connection_for(name).execute(sql, binds)
       else
+        join_batch(name)
         queue << [sql, binds]
         { "changes" => 0, "last_insert_id" => 0 }
       end
     end
 
+    def self.join_batch(name)
+      current = @batch_database
+      if current.nil?
+        @batch_database = name
+      elsif current != name
+        raise ArgumentError, "Model.batch spans databases (#{current} and #{name}); a batch runs on one database"
+      end
+    end
+
+    def self.select_all(sql, binds = [], database: PRIMARY)
+      connection_for(database).select_all(sql, binds.map { |b| database_value(b) })
+    end
+
+    def self.execute(sql, binds = [], database: PRIMARY)
+      write(sql, binds.map { |b| database_value(b) }, database: database)
+    end
+
+    def self.exec(sql, database: PRIMARY)
+      raise ArgumentError, "Model.exec can't run inside Model.batch" if batching?
+      raise ArgumentError, "Model.exec needs SQL text" unless sql.is_a?(String) && !sql.strip.empty?
+      connection_for(database).exec(sql)
+      nil
+    end
+
     def self.to_int(v)
       n = v.is_a?(Integer) ? v : v.to_s.to_i
       n > INT_MAX || n < INT_MIN ? nil : n
@@ -63,13 +108,51 @@ module Edgeway
       when :integer then to_int(v)
       when :float then v.is_a?(Float) ? v : v.to_s.to_f
       when :boolean then v == true || TRUE_STRINGS.include?(v.to_s)
+      when :bigint then to_bigint(v)
+      when :binary then to_binary(v)
       else v.to_s
       end
     end
 
-    def self.to_db(v)
-      return connection.quote_boolean(v) if v == true || v == false
-      v
+    INT64_MAX_DIGITS = "9223372036854775807"
+    INT64_MIN_DIGITS = "9223372036854775808"
+
+    # A bigint is held as its decimal String, as a number beyond 32 bits can't
+    # be an Integer in wasm.
+    def self.to_bigint(value)
+      text = value.to_s
+      return nil unless text.match?(/\A-?[0-9]+\z/)
+      negative = text.start_with?("-")
+      digits = text.sub(/\A-?0*/, "")
+      digits = "0" if digits.empty?
+      return nil unless within_int64?(digits, negative)
+      negative && digits != "0" ? "-#{digits}" : digits
+    end
+
+    def self.within_int64?(digits, negative)
+      limit = negative ? INT64_MIN_DIGITS : INT64_MAX_DIGITS
+      return digits.length < limit.length || (digits.length == limit.length && digits <= limit)
+    end
+
+    def self.to_binary(value)
+      return value.to_s.b unless value.is_a?(Hash)
+      return nil unless value.key?("$blob")
+      value["$blob"].to_s.unpack1("m0").b
+    rescue ArgumentError
+      nil
+    end
+
+    def self.encode_base64(bytes) = [bytes].pack("m0")
+
+    def self.blob(bytes)
+      { "$blob" => encode_base64(bytes) }
+    end
+
+    def self.database_value(value, type = nil)
+      return connection.quote_boolean(value) if value == true || value == false
+      return value.getutc.iso8601(3) if value.is_a?(Time)
+      return blob(value) if type == :binary && value.is_a?(String)
+      value
     end
 
     def self.underscore(name)

data/lib/edgeway/model/base.rb

@@ -40,6 +40,26 @@ module Edgeway
         @table_name || Inflector.pluralize(Model.underscore(name.split("::").last))
       end
 
+      def self.database=(name)
+        raise ArgumentError, "database name can't be blank" if name.nil? || name.to_s.empty?
+        @database = name.to_s
+      end
+
+      def self.own_database = @database
+
+      def self.database
+        klass = self
+        while klass
+          name = klass.own_database
+          return name unless name.nil?
+          break if klass == Base
+          klass = klass.superclass
+        end
+        Model::PRIMARY
+      end
+
+      def self.connection = Model.connection_for(database)
+
       def self.attribute_types = (@attribute_types ||= {})
       def self.attribute_defaults = (@attribute_defaults ||= {})
       def self.belongs_to_list = (@belongs_to ||= [])
@@ -82,12 +102,17 @@ module Edgeway
         ["id"] + attribute_types.keys
       end
 
+      def self.id_type = (@id_type ||= :integer)
+      def self.id_type=(type)
+        @id_type = type
+      end
+
       def self.type_of(col)
-        col == "id" ? :integer : attribute_types[col]
+        col == "id" ? id_type : attribute_types[col]
       end
 
       def self.all = Relation.new(self)
-      def self.where(conditions) = all.where(conditions)
+      def self.where(conditions, *args) = all.where(conditions, *args)
       def self.order(col, dir = :asc) = all.order(col, dir)
       def self.reorder(col, dir = :asc) = all.reorder(col, dir)
       def self.delete_all = all.delete_all
@@ -100,6 +125,7 @@ module Edgeway
       def self.pluck(col) = all.pluck(col)
       def self.first = all.first
       def self.find_by(conditions) = all.find_by(conditions)
+      def self.find_by_sql(sql, binds = []) = Model.select_all(sql, binds, database: database).map { |row| instantiate(row) }
       def self.find(id) = all.find(id)
 
       def self.find_or_create_by(conditions) = all.find_or_create_by(conditions)
@@ -148,16 +174,27 @@ module Edgeway
         types = self.class.attribute_types
         values.each do |k, v|
           key = k.to_s
-          write_attribute(key, v) if types.key?(key)
+          write_attribute(key, param_value(types[key], v, attrs)) if types.key?(key)
         end
       end
 
+      def param_value(type, value, attrs)
+        return value unless type == :binary && attrs.is_a?(HTTP::Parameters) && value.is_a?(String)
+        { "$blob" => value }
+      end
+
       def load_row(row)
-        self.class.columns.each { |col| @attributes[col] = Model.cast(self.class.type_of(col), row[col]) }
         @raw = {}
+        self.class.columns.each { |column| load_column(column, row[column]) }
         @persisted = true
       end
 
+      def load_column(column, value)
+        casted = Model.cast(self.class.type_of(column), value)
+        @attributes[column] = casted
+        @raw[column] = value if casted.nil? && !value.nil?
+      end
+
       def write_attribute(col, v)
         @raw[col] = v
         @attributes[col] = Model.cast(self.class.type_of(col), v)
@@ -165,9 +202,17 @@ module Edgeway
 
       def as_json
         h = {}
-        self.class.columns.each { |col| h[col] = @attributes[col] }
+        self.class.columns.each { |column| h[column] = json_value(column) }
         h
       end
+
+      private
+
+      def json_value(column)
+        value = @attributes[column]
+        return value unless self.class.type_of(column) == :binary && !value.nil?
+        Model.encode_base64(value)
+      end
     end
   end
 end

data/lib/edgeway/model/connection_registry.rb

@@ -0,0 +1,25 @@
+module Edgeway
+  module Model
+    class ConnectionRegistry
+      def initialize
+        @adapters = {}
+      end
+
+      def connect(name, adapter)
+        @adapters[name.to_s] = adapter
+      end
+
+      def disconnect(name)
+        @adapters.delete(name.to_s)
+      end
+
+      def connected?(name) = @adapters.key?(name.to_s)
+
+      def names = @adapters.keys
+
+      def fetch(name)
+        @adapters[name.to_s] || raise(ConfigurationError, "no database #{name}: it is not under databases: of this environment in config/database.yml")
+      end
+    end
+  end
+end

data/lib/edgeway/model/macros.rb

@@ -2,13 +2,17 @@ module Edgeway
   module Model
     module Macros
       def attribute(name, type, default: nil)
+        if name.to_s == "id"
+          self.id_type = type
+          return
+        end
         attribute_types[name.to_s] = type
         attribute_defaults[name.to_s] = default unless default.nil?
         define_method(name) { @attributes[name.to_s] }
         define_method("#{name}=") { |v| write_attribute(name.to_s, v) }
       end
 
-      # created_at / updated_at, as ISO 8601 text: SQLite (so D1) has no datetime
+      # created_at / updated_at, as ISO 8601 text: SQLite has no datetime
       # column type, the migrations declare them TEXT.
       def timestamps
         attribute :created_at, :datetime

data/lib/edgeway/model/persistence.rb

@@ -53,6 +53,7 @@ module Edgeway
       end
 
       def destroy
+        check_dependents_database
         if self.class.dependents.empty?
           delete_row
         else
@@ -86,10 +87,8 @@ module Edgeway
         cfg = nil
         self.class.has_manys.each { |h| cfg = h if h.name == name }
         raise ArgumentError, "no has_many #{name}" if cfg.nil?
-        # .dup: since matz/spinel 44119ab30 (Strings shared by reference),
-        # Spinel refuses this String as it is, or emits C that doesn't compile.
-        fk = cfg.foreign_key.nil? ? "#{Edgeway::Model.underscore(self.class.name.split("::").last)}_id" : cfg.foreign_key.dup
-        pk = self.class.column(cfg.primary_key.nil? ? "id" : cfg.primary_key.dup)
+        fk = cfg.foreign_key.nil? ? "#{Edgeway::Model.underscore(self.class.name.split("::").last)}_id" : cfg.foreign_key
+        pk = self.class.column(cfg.primary_key.nil? ? "id" : cfg.primary_key)
         Edgeway::Model::Base.model_named(name, self.class.name).where(fk => @attributes[pk])
       end
 
@@ -108,26 +107,34 @@ module Edgeway
 
       private
 
+      def check_dependents_database
+        self.class.dependents.each do |dependent|
+          child = Edgeway::Model::Base.model_named(dependent.name, self.class.name)
+          next if child.database == self.class.database
+          raise ArgumentError, "#{self.class.name} has_many :#{dependent.name}, dependent: :#{dependent.mode}, on database #{child.database}; destroy can't delete across databases atomically"
+        end
+      end
+
       def delete_row
-        conn = Model.connection
-        Model.write("DELETE FROM #{self.class.table_name} WHERE id = #{conn.placeholder(1)}", [id])
+        conn = self.class.connection
+        Model.write("DELETE FROM #{self.class.table_name} WHERE id = #{conn.placeholder(1)}", [id], database: self.class.database)
       end
 
       def update_row
-        conn = Model.connection
+        conn = self.class.connection
         cols = self.class.attribute_types.keys
-        values = cols.map { |c| Model.to_db(@attributes[c]) }
+        values = cols.map { |c| Model.database_value(@attributes[c], self.class.type_of(c)) }
         sets = cols.each_with_index.map { |c, i| "#{c} = #{conn.placeholder(i + 1)}" }.join(", ")
         Model.write("UPDATE #{self.class.table_name} SET #{sets} WHERE id = #{conn.placeholder(cols.size + 1)}",
-                     values + [id])
+                     values + [id], database: self.class.database)
       end
 
       def insert_row
         raise ArgumentError, "create isn't supported inside Model.batch" if Model.batching?
-        conn = Model.connection
+        conn = self.class.connection
         table = self.class.table_name
         cols = self.class.attribute_types.keys.reject { |c| @attributes[c].nil? }
-        values = cols.map { |c| Model.to_db(@attributes[c]) }
+        values = cols.map { |c| Model.database_value(@attributes[c], self.class.type_of(c)) }
         sql = "INSERT INTO #{table}"
         if cols.empty?
           sql += " DEFAULT VALUES"

data/lib/edgeway/model/relation.rb

@@ -3,12 +3,17 @@ module Edgeway
     class Relation
       # eager is the associations eager_load names (empty: none); records, when
       # set, are what to_a answers instead of a query (an eager-loaded has_many).
+      # conds are the WHERE terms (each with its own "?"s) and binds their
+      # values in order; eq_cols/eq_vals are the plain equality terms, which
+      # build copies into the new record.
       attr_writer :records
 
-      def initialize(model, where_cols = [], binds = [], order = [], limit = nil, offset = nil, eager = [])
+      def initialize(model, conds = [], binds = [], eq_cols = [], eq_vals = [], order = [], limit = nil, offset = nil, eager = [])
         @model = model
-        @where_cols = where_cols
+        @conds = conds
         @binds = binds
+        @eq_cols = eq_cols
+        @eq_vals = eq_vals
         @order = order
         @limit = limit
         @offset = offset
@@ -16,37 +21,45 @@ module Edgeway
         @records = nil
       end
 
-      def where(conditions)
-        cols = @where_cols.dup
+      def where(conditions, *args)
+        conds = @conds.dup
         binds = @binds.dup
-        conditions.each do |k, v|
-          col = @model.column(k)
-          casted = Model.cast(@model.type_of(col), v)
-          # An integer outside 32 bits can't be held as one; it goes as its
-          # text, which SQLite compares as the number it is, so nothing
-          # matches (a find on it is a 404).
-          casted = v.to_s if casted.nil? && !v.nil?
-          cols << col
-          binds << Model.to_db(casted)
+        eq_cols = @eq_cols.dup
+        eq_vals = @eq_vals.dup
+        if conditions.is_a?(String)
+          add_fragment(conditions, args, conds, binds)
+        else
+          raise ArgumentError, "where(Hash) takes no binds" unless args.empty?
+          conditions.each do |k, v|
+            column = @model.column(k)
+            type = @model.type_of(column)
+            if v.is_a?(Array)
+              add_in(column, type, v, conds, binds)
+            elsif v.is_a?(Range)
+              add_range(column, type, v, conds, binds)
+            else
+              add_equality(column, type, v, conds, binds, eq_cols, eq_vals)
+            end
+          end
         end
-        Relation.new(@model, cols, binds, @order, @limit, @offset, @eager)
+        Relation.new(@model, conds, binds, eq_cols, eq_vals, @order, @limit, @offset, @eager)
       end
 
       def order(col, dir = :asc)
-        Relation.new(@model, @where_cols, @binds, @order + [order_term(col, dir)], @limit, @offset, @eager)
+        Relation.new(@model, @conds, @binds, @eq_cols, @eq_vals, @order + [order_term(col, dir)], @limit, @offset, @eager)
       end
 
       # Replaces all the terms.
       def reorder(col, dir = :asc)
-        Relation.new(@model, @where_cols, @binds, [order_term(col, dir)], @limit, @offset, @eager)
+        Relation.new(@model, @conds, @binds, @eq_cols, @eq_vals, [order_term(col, dir)], @limit, @offset, @eager)
       end
 
       def limit(n)
-        Relation.new(@model, @where_cols, @binds, @order, count_arg("limit", n), @offset, @eager)
+        Relation.new(@model, @conds, @binds, @eq_cols, @eq_vals, @order, count_arg("limit", n), @offset, @eager)
       end
 
       def offset(n)
-        Relation.new(@model, @where_cols, @binds, @order, @limit, count_arg("offset", n), @eager)
+        Relation.new(@model, @conds, @binds, @eq_cols, @eq_vals, @order, @limit, count_arg("offset", n), @eager)
       end
 
       # Loads the has_manys and belongs_tos named of every record with the one
@@ -59,12 +72,12 @@ module Edgeway
         names.each do |n|
           eager << n.to_s unless eager.include?(n.to_s)
         end
-        Relation.new(@model, @where_cols, @binds, @order, @limit, @offset, eager)
+        Relation.new(@model, @conds, @binds, @eq_cols, @eq_vals, @order, @limit, @offset, eager)
       end
 
       # Same conditions, but to_a answers these records.
       def loaded(records)
-        relation = Relation.new(@model, @where_cols, @binds, @order, @limit, @offset)
+        relation = Relation.new(@model, @conds, @binds, @eq_cols, @eq_vals, @order, @limit, @offset)
         relation.records = records
         relation
       end
@@ -73,12 +86,12 @@ module Edgeway
         return @records unless @records.nil?
         return eager_records unless @eager.empty?
         sql, binds = select(@model.columns.join(", "), true)
-        Model.connection.select_all(sql, binds).map { |row| @model.instantiate(row) }
+        @model.connection.select_all(sql, binds).map { |row| @model.instantiate(row) }
       end
 
       def count
         sql, binds = select("1", false)
-        Model.connection.select_all("SELECT COUNT(*) AS n FROM (#{sql})", binds)[0]["n"].to_i
+        @model.connection.select_all("SELECT COUNT(*) AS n FROM (#{sql})", binds)[0]["n"].to_i
       end
 
       def exists? = limit(1).count > 0
@@ -87,16 +100,14 @@ module Edgeway
         name = @model.column(col)
         type = @model.type_of(name)
         sql, binds = select(name, true)
-        Model.connection.select_all(sql, binds).map { |row| Model.cast(type, row[name]) }
+        @model.connection.select_all(sql, binds).map { |row| Model.cast(type, row[name]) }
       end
 
       def first = (@order.empty? ? order(:id) : self).limit(1).to_a.first
 
       def delete_all
         raise ArgumentError, "delete_all doesn't support limit/offset" if @limit || @offset
-        conn = Model.connection
-        where_sql, _marks = where_clause(conn)
-        Model.write("DELETE FROM #{@model.table_name}#{where_sql}", @binds.compact)["changes"]
+        Model.write("DELETE FROM #{@model.table_name}#{where_clause}", @binds, database: @model.database)["changes"]
       end
 
       def destroy_all
@@ -110,7 +121,7 @@ module Edgeway
       def size = to_a.size
       def empty? = !exists?
 
-      def find_by(conditions) = Relation.new(@model, @where_cols, @binds, @order, @limit, nil, @eager).where(conditions).limit(1).to_a.first
+      def find_by(conditions) = Relation.new(@model, @conds, @binds, @eq_cols, @eq_vals, @order, @limit, nil, @eager).where(conditions).limit(1).to_a.first
 
       def find(id)
         find_by("id" => id) || raise(RecordNotFound, "#{@model.table_name} #{id} not found")
@@ -118,7 +129,7 @@ module Edgeway
 
       def build(attrs = {})
         record = @model.new(attrs)
-        @where_cols.each_with_index { |col, i| record.write_attribute(col, @binds[i]) }
+        @eq_cols.each_with_index { |col, i| record.write_attribute(col, @eq_vals[i]) }
         record
       end
 
@@ -154,6 +165,7 @@ module Edgeway
         @eager.each_with_index do |name, i|
           many_flags << eager_many?(name)
           other = Edgeway::Model::Base.model_named(name, @model.name)
+          check_same_database(name, other)
           theirs = "eager_#{name}"
           joins << " LEFT JOIN #{other.table_name} AS #{theirs} ON #{eager_on(name, other, theirs)}"
           cols = cols + other.columns.map { |c| "#{theirs}.#{c} AS c#{i}_#{c}" }
@@ -168,7 +180,7 @@ module Edgeway
         children = []
         position = {}
         seen = {}
-        Model.connection.select_all(sql, binds).each do |row|
+        @model.connection.select_all(sql, binds).each do |row|
           id = row["p_id"]
           i = position[id]
           if i.nil?
@@ -205,6 +217,11 @@ module Edgeway
         records
       end
 
+      def check_same_database(name, other)
+        return if other.database == @model.database
+        raise ArgumentError, "eager_load :#{name} joins #{other.name} (database #{other.database}) to #{@model.name} (database #{@model.database}); a JOIN can't cross databases"
+      end
+
       def eager_many?(name)
         many = nil
         @model.has_manys.each { |h| many = h if h.name == name }
@@ -223,9 +240,7 @@ module Edgeway
         if many.nil?
           one = nil
           @model.belongs_to_list.each { |b| one = b if b.name == name }
-          # .dup: since matz/spinel 44119ab30 (Strings shared by reference),
-          # Spinel refuses this String as it is, or emits C that doesn't compile.
-          return "#{theirs}.#{other.column(one.primary_key.dup)} = #{mine}.#{@model.column(one.foreign_key.dup)}"
+          return "#{theirs}.#{other.column(one.primary_key)} = #{mine}.#{@model.column(one.foreign_key)}"
         end
         fk = many.foreign_key.nil? ? "#{Model.underscore(@model.name.split("::").last)}_id" : many.foreign_key
         pk = many.primary_key.nil? ? "id" : many.primary_key
@@ -256,39 +271,74 @@ module Edgeway
         "#{@model.column(col)} #{d.upcase}"
       end
 
-      # " WHERE ..." (empty without conditions) and the number of placeholders
-      # it used. A nil value is IS NULL, with no bind.
-      def where_clause(conn)
-        marks = 0
-        return ["", marks] if @where_cols.empty?
-        conds = @where_cols.each_with_index.map do |c, i|
-          if @binds[i].nil?
-            "#{c} IS NULL"
-          else
-            marks += 1
-            "#{c} = #{conn.placeholder(marks)}"
-          end
+      def add_fragment(sql, values, conds, binds)
+        conds << "(#{sql})"
+        values.each do |v|
+          raise ArgumentError, "an Array bind in a SQL fragment isn't expanded; use where(column: [...])" if v.is_a?(Array)
+          binds << Model.database_value(v)
+        end
+      end
+
+      def add_in(column, type, values, conds, binds)
+        vals = values.map { |x| bind_value(type, x) }
+        rest = vals.compact
+        has_nil = rest.size < vals.size
+        if rest.empty?
+          conds << (has_nil ? "#{column} IS NULL" : "1 = 0")
+          return
+        end
+        term = "#{column} IN (#{rest.map { |_x| "?" }.join(", ")})"
+        conds << (has_nil ? "(#{term} OR #{column} IS NULL)" : term)
+        rest.each { |x| binds << x }
+      end
+
+      def add_range(column, type, range, conds, binds)
+        lo = range.begin
+        hi = range.end
+        unless lo.nil?
+          conds << "#{column} >= ?"
+          binds << bind_value(type, lo)
+        end
+        unless hi.nil?
+          conds << "#{column} #{range.exclude_end? ? "<" : "<="} ?"
+          binds << bind_value(type, hi)
+        end
+      end
+
+      def add_equality(column, type, value, conds, binds, eq_cols, eq_vals)
+        bound = bind_value(type, value)
+        if bound.nil?
+          conds << "#{column} IS NULL"
+        else
+          conds << "#{column} = ?"
+          binds << bound
         end
-        [" WHERE " + conds.join(" AND "), marks]
+        eq_cols << column
+        eq_vals << bound
+      end
+
+      # The value as it is bound. An integer outside 32 bits can't be held as
+      # one; it goes as its text, which SQLite compares as the number it is
+      # (an equality on it matches nothing: a find on it is a 404).
+      def bind_value(type, v)
+        v = Model.database_value(v) if v.is_a?(Time)
+        casted = Model.cast(type, v)
+        casted = v.to_s if casted.nil? && !v.nil?
+        Model.database_value(casted, type)
       end
 
+      def where_clause = @conds.empty? ? "" : " WHERE " + @conds.join(" AND ")
+
       def select(what, ordered)
-        conn = Model.connection
-        where_sql, _marks = where_clause(conn)
-        sql = "SELECT #{what} FROM #{@model.table_name}#{where_sql}"
+        sql = "SELECT #{what} FROM #{@model.table_name}#{where_clause}"
         sql += " ORDER BY #{@order.join(", ")}" if ordered && !@order.empty?
-        binds = @binds.compact
         if @limit
-          binds = binds + [@limit]
-          sql += " LIMIT #{conn.placeholder(binds.size)}"
+          sql += " LIMIT #{@limit}"
         elsif @offset
           sql += " LIMIT -1"
         end
-        if @offset
-          binds = binds + [@offset]
-          sql += " OFFSET #{conn.placeholder(binds.size)}"
-        end
-        [sql, binds]
+        sql += " OFFSET #{@offset}" if @offset
+        [sql, @binds]
       end
     end
   end