edgeway 0.1.0 → 0.3.0

data/lib/edgeway/controller/caching.rb

@@ -0,0 +1,140 @@
+module Edgeway
+  module Controller
+    # HTTP caching helpers for actions:
+    #
+    #   def show
+    #     todo = Todo.find(params["id"])
+    #     render json: todo if stale?(etag: todo, last_modified: todo.updated_at)
+    #   end
+    #
+    # Only the validators an action names are used; nothing is derived from
+    # the response body.
+    module Caching
+      ETAG_LENGTH = 32
+
+      def expires_in(seconds, public: false, must_revalidate: false)
+        raise ArgumentError, "seconds must be a non-negative Integer" unless Caching.duration?(seconds)
+        value = "max-age=#{seconds}, #{public ? "public" : "private"}"
+        value += ", must-revalidate" if must_revalidate
+        @headers["Cache-Control"] = value
+        nil
+      end
+
+      def no_store
+        @headers["Cache-Control"] = "no-store"
+        nil
+      end
+
+      # Returns true when it answered 304 (the action is done), false
+      # otherwise.
+      def fresh_when(etag: nil, last_modified: nil, public: false)
+        etag_value = etag.nil? ? nil : Caching.etag_for(etag)
+        modified_time = Caching.time_for(last_modified)
+        @headers["ETag"] = etag_value unless etag_value.nil?
+        @headers["Last-Modified"] = modified_time.httpdate unless modified_time.nil?
+        set_default_cache_control(public)
+        return false unless cacheable_request? && request_fresh?(etag_value, modified_time)
+        remove_representation_headers
+        head :not_modified
+        true
+      end
+
+      # fresh_when, answering true when the action should go on to render.
+      def stale?(etag: nil, last_modified: nil, public: false)
+        !fresh_when(etag: etag, last_modified: last_modified, public: public)
+      end
+
+      # Integer() gives Spinel a type for a parameter no call site types.
+      def self.duration?(seconds)
+        seconds.is_a?(Integer) && Integer(seconds) >= 0
+      end
+
+      # Weak, because a proxy may recompress the body and weaken a strong
+      # validator on the way.
+      def self.etag_for(source)
+        digest = Digest::SHA256.hexdigest(etag_source(source))
+        "W/\"#{digest[0, ETAG_LENGTH]}\""
+      end
+
+      def self.etag_source(source)
+        if source.is_a?(Model::Base)
+          model_source(source)
+        elsif source.is_a?(Model::Relation)
+          list_source(source.to_a)
+        elsif source.is_a?(Array)
+          list_source(source)
+        else
+          source.to_s
+        end
+      end
+
+      def self.model_source(model)
+        updated_at = model.as_json["updated_at"].to_s
+        raise ArgumentError, "#{model.class.name} has no updated_at (add timestamps)" if updated_at.empty?
+        "#{model.class.name}/#{model.id}/#{updated_at}"
+      end
+
+      def self.list_source(items)
+        "[" + items.map { |item| etag_source(item) }.join(",") + "]"
+      end
+
+      def self.time_for(value)
+        return nil if value.nil?
+        return value.getutc if value.is_a?(Time)
+        raise ArgumentError, "last_modified must be a Time or an ISO 8601 String" unless value.is_a?(String)
+        begin
+          Time.iso8601(value).utc
+        rescue ArgumentError
+          raise ArgumentError, "last_modified is not an ISO 8601 String: #{value.inspect}"
+        end
+      end
+
+      # The validators match the ones the client sent (RFC 9110 13.1.2,
+      # 13.1.3): If-None-Match decides when it is present, and
+      # If-Modified-Since is then ignored.
+      def self.fresh?(none_match, modified_since, etag, last_modified)
+        return etag_listed?(none_match, etag) unless none_match.empty?
+        return false if modified_since.empty? || last_modified.nil?
+        since = parse_http_date(modified_since)
+        !since.nil? && last_modified.to_i <= since.to_i
+      end
+
+      def self.etag_listed?(header, etag)
+        return false if etag.nil?
+        candidates = header.split(",").map { |candidate| candidate.strip }
+        return true if candidates.include?("*")
+        candidates.any? { |candidate| candidate.delete_prefix("W/") == etag.delete_prefix("W/") }
+      end
+
+      def self.parse_http_date(text)
+        Time.httpdate(text).utc
+      rescue ArgumentError
+        nil
+      end
+
+      private
+
+      def set_default_cache_control(public)
+        return if header_set?("Cache-Control")
+        @headers["Cache-Control"] = "max-age=0, #{public ? "public" : "private"}, must-revalidate"
+      end
+
+      def header_set?(name)
+        @headers.keys.any? { |key| key.downcase == name.downcase }
+      end
+
+      def remove_representation_headers
+        @headers.delete("Content-Type")
+        @headers.delete("X-Content-Type-Options")
+      end
+
+      def cacheable_request?
+        @request.method == "GET" || @request.method == "HEAD"
+      end
+
+      def request_fresh?(etag_value, modified_time)
+        Caching.fresh?(@request.header("If-None-Match"), @request.header("If-Modified-Since"), etag_value, modified_time)
+      end
+    end
+  end
+end

data/lib/edgeway/controller/callbacks.rb

@@ -9,6 +9,10 @@ module Edgeway
         @except = except
       end
 
+      def run(controller)
+        controller.send(@name)
+      end
+
       def applies?(action)
         return false if @except.include?(action)
         @only.empty? || @only.include?(action)
@@ -19,7 +23,7 @@ module Edgeway
       def run_before_actions(action)
         self.class.all_before_actions.each do |callback|
           next unless callback.applies?(action)
-          send(callback.name)
+          callback.run(self)
           return false if performed?
         end
         true

data/lib/edgeway/controller/dispatcher.rb

@@ -15,6 +15,7 @@ module Edgeway
         klass = controller_class(route)
         raise RoutingError, "no controller for #{route.controller_path}" if klass.nil?
         controller = klass.new(request)
+        controller.action_name = route.action
         # A route whose action isn't defined (or is one of Base's own public
         # methods) is a 404, as in Rails.
         raise RoutingError, "no route for #{request.method} #{request.path}" unless controller.action?(route.action)
@@ -26,7 +27,7 @@ module Edgeway
           # a route can't reach a private method.
           action = route.action.to_sym
           controller.public_send(action) if controller.run_before_actions(route.action)
-          controller.head(:no_content) unless controller.performed?
+          implicit_render(controller, route) unless controller.performed?
         rescue => e
           raise e unless controller.rescue_with_handler(e)
           # A handler that rendered nothing answers 204, as an action does.
@@ -34,6 +35,15 @@ module Edgeway
         end
         controller.to_response
       end
+
+      def self.implicit_render(controller, route)
+        content = controller._render_view(route.action)
+        if content.nil?
+          controller.head(:no_content)
+        else
+          controller.render(html: View::SafeHTML.new(content))
+        end
+      end
     end
   end
 end

data/lib/edgeway/controller/rate_limiting.rb

@@ -0,0 +1,145 @@
+module Edgeway
+  module Controller
+    @rate_limiter = RateLimit::NullLimiter.new
+
+    def self.rate_limiter = @rate_limiter
+
+    def self.rate_limiter=(limiter)
+      @rate_limiter = limiter
+    end
+
+    # Rate limiting through a limiter binding:
+    #
+    #   class PostsController < ApplicationController
+    #     rate_limit "WRITE_LIMITER", only: [:create], retry_after: 10
+    #   end
+    #
+    # It is a before_action. Over the limit it raises TooManyRequests (429).
+    # The limit and the period are set on the binding, not here. A by: method is
+    # never a route's action (Base.rate_limit adds it to the non-actions).
+    module RateLimiting
+      class Rule < Callback
+        attr_reader :binding_name, :by, :scope_name, :retry_after
+
+        def self.build(binding_name, by, name, retry_after, only, except)
+          raise ArgumentError, "the limiter binding name must be a non-empty String" unless binding_name.is_a?(String) && !binding_name.empty?
+          raise ArgumentError, "by: must be a Symbol" unless by.nil? || by.is_a?(Symbol)
+          raise ArgumentError, "name: must be a String" unless name.nil? || name.is_a?(String)
+          raise ArgumentError, "retry_after: must be a positive Integer" unless retry_after.nil? || RateLimiting.positive_integer?(retry_after)
+          new(binding_name, by, name, retry_after.nil? ? 0 : retry_after, only.map(&:to_s), except.map(&:to_s))
+        end
+
+        def initialize(binding_name, by, name, retry_after, only, except)
+          super("rate_limit", only, except)
+          @binding_name = binding_name
+          @by = by
+          @scope_name = name
+          @retry_after = retry_after
+        end
+
+        def run(controller)
+          controller.send(:enforce_rate_limit, self)
+        end
+      end
+
+      IPV6_GROUPS = 8
+      IPV6_PREFIX_GROUPS = 4
+      IPV4_OCTETS = 4
+      IPV4_MAPPED_ZERO_GROUPS = 5
+      IPV4_MAPPED_MARKER_GROUP = 5
+      IPV4_HIGH_GROUP = 6
+      IPV4_LOW_GROUP = 7
+      HEX_DIGITS = "0123456789abcdef"
+
+      # An IPv6 client usually has a whole /64, so its address is keyed by
+      # that prefix; an IPv4 address (or one that does not parse) is kept.
+      def self.address_key(address)
+        return address unless address.include?(":")
+
+        text = address.downcase.split("%")[0].to_s
+        groups = ipv6_groups(embedded_ipv4_as_hex(text))
+        return address if groups.nil?
+
+        ipv4_mapped?(groups) ? ipv4_from_groups(groups) : groups[0, IPV6_PREFIX_GROUPS].join(":") + "::/64"
+      end
+
+      # "::ffff:192.0.2.1" -> "::ffff:c000:201", so the dotted tail parses as two groups.
+      def self.embedded_ipv4_as_hex(text)
+        colon = text.rindex(":").to_i
+        octets = text[colon + 1, text.length].to_s.split(".", -1)
+        return text unless octets.length == IPV4_OCTETS && octets.all? { |octet| decimal_octet?(octet) }
+
+        values = octets.map { |octet| octet.to_i }
+        high = (values[0] * 256 + values[1]).to_s(16)
+        low = (values[2] * 256 + values[3]).to_s(16)
+        text[0, colon + 1].to_s + high + ":" + low
+      end
+
+      def self.decimal_octet?(octet)
+        octet.length >= 1 && octet.length <= 3 && octet.each_char.all? { |digit| "0123456789".include?(digit) } && octet.to_i <= 255
+      end
+
+      def self.ipv4_mapped?(groups)
+        groups[0, IPV4_MAPPED_ZERO_GROUPS].all? { |group| group == "0" } && groups[IPV4_MAPPED_MARKER_GROUP] == "ffff"
+      end
+
+      def self.ipv4_from_groups(groups)
+        high = groups[IPV4_HIGH_GROUP].to_i(16)
+        low = groups[IPV4_LOW_GROUP].to_i(16)
+        [high / 256, high % 256, low / 256, low % 256].join(".")
+      end
+
+      def self.ipv6_groups(text)
+        halves = text.split("::", -1)
+        return nil if halves.empty? || halves.length > 2
+
+        head = group_list(halves[0])
+        tail = halves.length == 2 ? group_list(halves[1]) : []
+        return nil if head.nil? || tail.nil?
+
+        filler = IPV6_GROUPS - head.length - tail.length
+        return nil if halves.length == 1 ? filler != 0 : filler < 1
+
+        head + Array.new(filler, "0") + tail
+      end
+
+      def self.group_list(text)
+        return [] if text.empty?
+
+        groups = text.split(":", -1).map { |group| normalized_group(group) }
+        groups.include?("") ? nil : groups
+      end
+
+      def self.normalized_group(group)
+        return "" if group.empty? || group.length > 4 || !group.each_char.all? { |digit| HEX_DIGITS.include?(digit) }
+
+        group.to_i(16).to_s(16)
+      end
+
+      # Integer() gives Spinel a type for a parameter no call site types.
+      def self.positive_integer?(value)
+        value.is_a?(Integer) && Integer(value) > 0
+      end
+
+      private
+
+      def enforce_rate_limit(rule)
+        return unless Edgeway::Controller.rate_limiter.exceeded?(rule.binding_name, rate_limit_key_for(rule))
+
+        raise TooManyRequests.new("rate limit exceeded (#{rule.binding_name})", rule.retry_after)
+      end
+
+      def rate_limit_key_for(rule)
+        scope = rule.scope_name.nil? ? self.class.name : rule.scope_name
+        "#{scope}:#{rule.by.nil? ? default_rate_limit_key : send(rule.by).to_s}"
+      end
+
+      def default_rate_limit_key
+        subject = authenticated? ? current_claims["sub"].to_s : ""
+        return "user:#{subject}" unless subject.empty?
+
+        "ip:#{RateLimiting.address_key(request.remote_addr)}"
+      end
+    end
+  end
+end

data/lib/edgeway/controller/rendering.rb

@@ -10,6 +10,8 @@ module Edgeway
         "service_unavailable" => 503
       }
 
+      UNSET = Object.new
+
       def self.json_response(status, json_text)
         HTTP::Response.json(status, json_text)
       end
@@ -39,10 +41,28 @@ module Edgeway
         end
       end
 
-      def render(json:, status: 200)
-        @status = Rendering.status_code(status)
-        @headers["Content-Type"] = "application/json"
-        @response_body = JSON.generate(Rendering.json_value(json)) + "\n"
+      def self.html_content(value)
+        value.is_a?(View::SafeHTML) ? value.to_s : View.escape(value)
+      end
+
+      def render(template = nil, json: UNSET, html: UNSET, status: 200, layout: true)
+        code = Rendering.status_code(status)
+        if !json.equal?(UNSET)
+          body = JSON.generate(Rendering.json_value(json)) + "\n"
+          @headers["Content-Type"] = "application/json"
+        else
+          content = html.equal?(UNSET) ? nil : Rendering.html_content(html)
+          if content.nil?
+            name = template.nil? ? @action_name : template.to_s
+            content = _render_view(name)
+            raise MissingTemplate, "no template #{name.inspect} for #{self.class.name}" if content.nil?
+          end
+          body = layout ? _render_layout(content) : content
+          @headers["Content-Type"] = "text/html; charset=utf-8"
+          @headers["X-Content-Type-Options"] = "nosniff"
+        end
+        @status = code
+        @response_body = body
         @performed = true
       end
 

data/lib/edgeway/db/adapter.rb

@@ -1,6 +1,18 @@
+require_relative "query_stats"
+
 module Edgeway
   module DB
     class Adapter
+      MAX_BINDS = 100
+
+      def query_stats
+        @query_stats ||= QueryStats.new
+      end
+
+      def record_meta(meta)
+        query_stats.add(meta)
+      end
+
       def select_all(sql, binds)
         raise Error, "#{self.class} does not define select_all"
       end
@@ -9,6 +21,10 @@ module Edgeway
         raise Error, "#{self.class} does not define execute"
       end
 
+      def exec(sql)
+        raise Error, "#{self.class} does not define exec"
+      end
+
       def batch(statements)
         raise Error, "#{self.class} does not define batch"
       end
@@ -19,11 +35,33 @@ module Edgeway
         rows[0]
       end
 
+      def last_insert_id_of(value)
+        return 0 if value.nil?
+        number = value.to_i
+        number > Edgeway::Model::INT_MAX || number < Edgeway::Model::INT_MIN ? value.to_s : number
+      rescue RangeError
+        value.to_s
+      end
+
+      def check_binds(binds)
+        return if binds.size <= MAX_BINDS
+        raise ArgumentError, "too many bind parameters: #{binds.size} (at most #{MAX_BINDS})"
+      end
+
       def fail_with(message)
         raise RecordNotUnique, message if message.include?("UNIQUE constraint failed")
+        raise NotNullViolation, message if message.include?("NOT NULL constraint failed")
+        raise InvalidForeignKey, message if message.include?("FOREIGN KEY constraint failed")
+        raise CheckViolation, message if message.include?("CHECK constraint failed")
         raise DatabaseError, message
       end
 
+      def raise_error_result(res, prefix = "")
+        message = "#{prefix}#{res["error"]}"
+        raise DatabaseUnavailable, message if res.key?("unavailable")
+        fail_with(message)
+      end
+
       def supports_returning? = true
       def placeholder(n) = "?"
       def quote_boolean(value) = value ? 1 : 0

data/lib/edgeway/db/memory.rb

@@ -32,8 +32,8 @@ module Edgeway
       end
 
       # Makes the next query or execute whose SQL contains `containing` (any,
-      # by default) fail with this database message, after logging it, as D1
-      # would: "UNIQUE constraint failed: t.c" is a RecordNotUnique.
+      # by default) fail with this database message, after logging it, as the
+      # database would: "UNIQUE constraint failed: t.c" is a RecordNotUnique.
       def fail_next(message, containing = "")
         @failure = message
         @failure_on = containing
@@ -42,18 +42,25 @@ module Edgeway
       def supports_returning? = @returning
 
       def select_all(sql, binds)
+        check_binds(binds)
         record(sql, binds)
         @queue.empty? ? [] : @queue.shift
       end
 
       def execute(sql, binds)
+        check_binds(binds)
         record(sql, binds)
         id = @next_id
         @next_id += 1
         { "changes" => @changes, "last_insert_id" => id }
       end
 
+      def exec(sql)
+        record(sql, [])
+      end
+
       def batch(statements)
+        statements.each { |s| check_binds(s[1]) }
         @log << "BATCH #{statements.size}"
         statements.map { |s| execute(s[0], s[1]) }
       end

data/lib/edgeway/db/query_stats.rb

@@ -0,0 +1,42 @@
+module Edgeway
+  module DB
+    # What the database reported for one request.
+    class QueryStats
+      MAX_COUNT = 2147483647
+
+      attr_reader :queries, :rows_read, :rows_written, :duration_ms, :served_by_region, :served_by_primary
+
+      def initialize
+        @queries = 0
+        @rows_read = 0
+        @rows_written = 0
+        @duration_ms = 0.0
+        @served_by_region = ""
+        @served_by_primary = true
+      end
+
+      def add(meta)
+        rows_read = capped_sum(@rows_read, meta["rows_read"])
+        rows_written = capped_sum(@rows_written, meta["rows_written"])
+        duration_ms = @duration_ms + meta["duration"].to_f
+        @rows_read = rows_read
+        @rows_written = rows_written
+        @duration_ms = duration_ms
+        @served_by_region = meta["served_by_region"].to_s if meta.key?("served_by_region")
+        @served_by_primary = meta["served_by_primary"] != false if meta.key?("served_by_primary")
+        @queries = capped_sum(@queries, 1)
+      end
+
+      def log_fields
+        { "queries" => @queries, "rows_read" => @rows_read, "rows_written" => @rows_written, "db_ms" => @duration_ms.round(2) }
+      end
+
+      private
+
+      def capped_sum(total, count)
+        return MAX_COUNT if count.to_i > MAX_COUNT - total
+        total + count.to_i
+      end
+    end
+  end
+end

data/lib/edgeway/db/sqlite.rb

@@ -20,6 +20,7 @@ module Edgeway
       ffi_func :sqlite3_prepare_v2,      [:ptr, :str, :int, :ptr, :ptr],    :int
       ffi_func :sqlite3_bind_text,       [:ptr, :int, :str, :int, :ptr],    :int
       ffi_func :sqlite3_bind_int64,      [:ptr, :int, :long],               :int
+      ffi_func :sqlite3_bind_blob,       [:ptr, :int, :str, :int, :ptr],    :int
       ffi_func :sqlite3_bind_double,     [:ptr, :int, :double],             :int
       ffi_func :sqlite3_bind_null,       [:ptr, :int],                      :int
       ffi_func :sqlite3_step,            [:ptr],                            :int
@@ -35,6 +36,35 @@ module Edgeway
       ffi_func :sqlite3_changes,         [:ptr],                            :int
       ffi_func :sqlite3_libversion_number, [],                              :int
 
+      # A BLOB can hold NUL, which would cut a :str result short, so it is read
+      # as hex text.
+      ffi_source <<~C
+        #include <stdlib.h>
+
+        extern const void *sqlite3_column_blob(void *statement, int column);
+        extern int sqlite3_column_bytes(void *statement, int column);
+
+        static char *hex;
+        static int hex_capacity;
+
+        const char *column_hex(void *statement, int column) {
+          const unsigned char *bytes = sqlite3_column_blob(statement, column);
+          int length = sqlite3_column_bytes(statement, column);
+          if (2 * length + 1 > hex_capacity) {
+            hex = realloc(hex, 2 * length + 1);
+            if (!hex) abort();
+            hex_capacity = 2 * length + 1;
+          }
+          for (int i = 0; i < length; i++) {
+            hex[2 * i] = "0123456789abcdef"[bytes[i] >> 4];
+            hex[2 * i + 1] = "0123456789abcdef"[bytes[i] & 15];
+          }
+          hex[2 * length] = 0;
+          return hex;
+        }
+      C
+      ffi_func :column_hex, [:ptr, :int], :str
+
       ffi_buffer :db_out,   8
       ffi_buffer :stmt_out, 8
       ffi_read_ptr :read_ptr, 0
@@ -43,6 +73,7 @@ module Edgeway
     class SQLiteAdapter < Adapter
       INTEGER = 1
       FLOAT = 2
+      BLOB = 4
       NULL = 5
 
       attr_reader :log
@@ -63,6 +94,7 @@ module Edgeway
       def supports_returning? = @returning
 
       def select_all(sql, binds)
+        check_binds(binds)
         stmt = start(sql, binds)
         rows = []
         rc = SQLiteFFI.sqlite3_step(stmt)
@@ -75,26 +107,25 @@ module Edgeway
       end
 
       def execute(sql, binds)
+        check_binds(binds)
         stmt = start(sql, binds)
         rc = SQLiteFFI.sqlite3_step(stmt)
         while rc == SQLiteFFI::ROW
           rc = SQLiteFFI.sqlite3_step(stmt)
         end
         finish(stmt, rc)
-        { "changes" => SQLiteFFI.sqlite3_changes(@db), "last_insert_id" => SQLiteFFI.sqlite3_last_insert_rowid(@db) }
+        { "changes" => SQLiteFFI.sqlite3_changes(@db), "last_insert_id" => last_insert_id_of(SQLiteFFI.sqlite3_last_insert_rowid(@db)) }
+      end
+
+      def exec(sql)
+        @log << "#{sql} | []"
+        in_transaction { sql.split("\n").each { |line| run_script(line) unless line.strip.empty? } }
       end
 
       def batch(statements)
         @log << "BATCH #{statements.size}"
-        run_script("BEGIN")
         results = []
-        begin
-          statements.each { |s| results << execute(s[0], s[1]) }
-        rescue => e
-          run_script("ROLLBACK")
-          raise e
-        end
-        run_script("COMMIT")
+        in_transaction { statements.each { |s| results << execute(s[0], s[1]) } }
         results
       end
 
@@ -113,6 +144,17 @@ module Edgeway
 
       private
 
+      def in_transaction
+        run_script("BEGIN")
+        begin
+          yield
+        rescue => e
+          run_script("ROLLBACK")
+          raise e
+        end
+        run_script("COMMIT")
+      end
+
       def run_script(sql_text)
         rc = SQLiteFFI.sqlite3_exec(@db, sql_text, nil, nil, nil)
         fail_with(SQLiteFFI.sqlite3_errmsg(@db)) if rc != SQLiteFFI::OK
@@ -122,6 +164,7 @@ module Edgeway
       # finalized before the error is raised.
       def start(sql, binds)
         @log << "#{sql} | #{JSON.generate(binds)}"
+        check_blob_binds(binds)
         rc = SQLiteFFI.sqlite3_prepare_v2(@db, sql, -1, SQLiteFFI.stmt_out, nil)
         if rc != SQLiteFFI::OK
           message = SQLiteFFI.sqlite3_errmsg(@db)
@@ -148,6 +191,8 @@ module Edgeway
           SQLiteFFI.sqlite3_bind_int64(stmt, n, value)
         elsif value.is_a?(Float)
           SQLiteFFI.sqlite3_bind_double(stmt, n, value)
+        elsif value.is_a?(Hash)
+          bind_blob(stmt, n, value)
         elsif value == true
           SQLiteFFI.sqlite3_bind_int64(stmt, n, 1)
         elsif value == false
@@ -158,6 +203,19 @@ module Edgeway
         end
       end
 
+      def check_blob_binds(binds)
+        binds.each do |value|
+          next unless value.is_a?(Hash)
+          bytes = value.key?("$blob") ? Edgeway::Model.cast(:binary, value) : nil
+          raise ArgumentError, "a Hash bind must be {\"$blob\" => base64}: #{value}" if bytes.nil?
+        end
+      end
+
+      def bind_blob(statement, position, value)
+        bytes = Edgeway::Model.cast(:binary, value).to_s
+        SQLiteFFI.sqlite3_bind_blob(statement, position, bytes, bytes.bytesize, -1)
+      end
+
       # Finalizes the statement; raises if its last step failed.
       def finish(stmt, rc)
         message = rc == SQLiteFFI::DONE ? "" : SQLiteFFI.sqlite3_errmsg(@db)
@@ -165,6 +223,10 @@ module Edgeway
         fail_with(message) if rc != SQLiteFFI::DONE
       end
 
+      def read_blob(statement, column)
+        Edgeway::Model.blob([SQLiteFFI.column_hex(statement, column)].pack("H*"))
+      end
+
       def read_row(stmt)
         row = {}
         n = SQLiteFFI.sqlite3_column_count(stmt)
@@ -178,6 +240,8 @@ module Edgeway
             row[name] = SQLiteFFI.sqlite3_column_int64(stmt, i)
           elsif type == FLOAT
             row[name] = SQLiteFFI.sqlite3_column_double(stmt, i)
+          elsif type == BLOB
+            row[name] = read_blob(stmt, i)
           else
             row[name] = SQLiteFFI.sqlite3_column_text(stmt, i)
           end