amalgalite 1.9.4-x64-mingw-ucrt → 2.0.0-x64-mingw-ucrt

data/ext/amalgalite/c/sqlite3ext.h

@@ -366,6 +366,12 @@ struct sqlite3_api_routines {
   /* Version 3.44.0 and later */
   void *(*get_clientdata)(sqlite3*,const char*);
   int (*set_clientdata)(sqlite3*, const char*, void*, void(*)(void*));
+  /* Version 3.50.0 and later */
+  int (*setlk_timeout)(sqlite3*,int,int);
+  /* Version 3.51.0 and later */
+  int (*set_errmsg)(sqlite3*,int,const char*);
+  int (*db_status64)(sqlite3*,int,sqlite3_int64*,sqlite3_int64*,int);
+  
 };
 
 /*
@@ -699,6 +705,11 @@ typedef int (*sqlite3_loadext_entry)(
 /* Version 3.44.0 and later */
 #define sqlite3_get_clientdata         sqlite3_api->get_clientdata
 #define sqlite3_set_clientdata         sqlite3_api->set_clientdata
+/* Version 3.50.0 and later */
+#define sqlite3_setlk_timeout          sqlite3_api->setlk_timeout
+/* Version 3.51.0 and later */
+#define sqlite3_set_errmsg             sqlite3_api->set_errmsg
+#define sqlite3_db_status64            sqlite3_api->db_status64
 #endif /* !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION) */
 
 #if !defined(SQLITE_CORE) && !defined(SQLITE_OMIT_LOAD_EXTENSION)

data/lib/amalgalite/column.rb

@@ -27,6 +27,10 @@ module Amalgalite
     # the column name
     attr_accessor :name
 
+    # The column "as" name. This is what its name is in the query, if this is
+    # part of the query, then this is the result, otherwise it is the name
+    attr_accessor :as_name
+
     # the default value of the column.   This may not have a value and that
     # either means that there is no default value, or one could not be
     # determined.
@@ -35,7 +39,10 @@ module Amalgalite
 
     # the declared data type of the column in the original sql that created the
     # column
-    attr_accessor :declared_data_type
+    attr_reader :declared_data_type
+
+    # the declared data type that is tokenized and then downcased
+    attr_reader :normalized_declared_data_type
 
     # the collation sequence name of the column
     attr_accessor :collation_sequence_name
@@ -47,15 +54,26 @@ module Amalgalite
     ##
     # Create a column with its name and associated table
     #
-    def initialize( db, table, name, order)
+    def initialize( db, table, name, order, as_name = nil)
       @db                 = db
       @table              = table
       @name               = name
       @order              = Float(order).to_i
+      @as_name            = as_name || name
       @declared_data_type = nil
+      @normalized_declared_data_type = nil
       @default_value      = nil
     end
 
+    def declared_data_type=(input)
+      return nil if input.nil?
+      @declared_data_type = input
+
+      # just the first word token
+      @normalized_declared_data_type = input[/^\w+/]&.downcase
+      return @declared_data_type
+    end
+
     # true if the column has a default value
     def has_default_value?
       not default_value.nil?

data/lib/amalgalite/result/row.rb

@@ -0,0 +1,83 @@
+#--
+# Copyright (c) 2025 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite
+  class Result
+    ##
+    # The class that represents a single row from a query.
+    #
+    class Row
+      # The result object this row is retrivved from, nil if all values
+      # are materialized
+      attr_reader :result
+
+      # A Hash that maps the field names to indexes in values
+      # This may be linked to shared field from the result
+      attr_reader :field_map
+
+      # An array containing the values from the row
+      attr_reader :values
+      alias to_a values
+
+      def initialize(result: nil, field_map:, values:)
+        @result = result
+        @field_map = field_map
+        @values = values
+        self.freeze
+      end
+
+      def fields
+        @field_map.keys
+      end
+
+      def store_by_index(index, value)
+        @values[index] = value
+      end
+
+      def store(field_name_or_index, value)
+        index = field_name_or_index_to_index(field_name_or_index)
+        @values[index] = value
+      end
+      alias []= store
+
+      def fetch(field_name_or_index)
+        case field_name_or_index
+        when Integer
+          @values[field_name_or_index]
+        when Symbol, String
+          @values[field_map[field_name_or_index]]
+        else
+          raise Amalgalite::Error, "Unknown type (#{field_name_or_index.class}) of key for a Row value: #{field_name_or_index}"
+        end
+      end
+      alias [] fetch
+
+      def first
+        fetch(0)
+      end
+
+      def length
+        @values.size
+      end
+
+      def to_h
+        Hash[@field_map.keys.zip(values)]
+      end
+
+      private
+
+      def field_name_or_index_to_index(field_name_or_index)
+        case field_name_or_index
+        when Integer
+          field_name_or_index
+        when Symbol, String
+          @values[@field_map[field_name_or_index]]
+        else
+          raise Amalgalite::Error, "Unknown type (#{field_name_or_index.class}) of key for a Row value: #{field_name_or_index}"
+        end
+      end
+    end
+  end
+end

data/lib/amalgalite/result.rb

@@ -0,0 +1,15 @@
+#--
+# Copyright (c) 2025 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+module Amalgalite
+  ##
+  # The class to that represents the query result.
+  #
+  class Result
+
+  end
+end
+
+require 'amalgalite/result/row'

data/lib/amalgalite/statement.rb

@@ -4,8 +4,7 @@
 #++
 #
 require 'date'
-require 'arrayfields'
-require 'ostruct'
+require 'amalgalite/result'
 
 module Amalgalite
   class Statement
@@ -258,10 +257,11 @@ module Amalgalite
     # Database#type_map
     #
     def next_row
-      row = []
+      row = nil
       case rc = @stmt_api.step
       when ResultCode::ROW
-        result_meta.each_with_index do |col, idx|
+        row = ::Amalgalite::Result::Row.new(field_map: result_field_map, values: Array.new(result_meta.size))
+        result_meta.each.with_index do |col, idx|
           value = nil
           column_type = @stmt_api.column_type( idx )
           case column_type
@@ -278,28 +278,26 @@ module Amalgalite
             # blob api, otherwise we have to use the all at once version.
             if using_rowid_column? then
               value = Amalgalite::Blob.new( :db_blob => SQLite3::Blob.new( db.api,
-                                                                           col.schema.db,
-                                                                           col.schema.table,
-                                                                           col.schema.name,
+                                                                           col.db,
+                                                                           col.table,
+                                                                           col.name,
                                                                            @stmt_api.column_int64( @rowid_index ),
                                                                            "r"),
-                                            :column => col.schema)
+                                            :column => col)
             else
-              value = Amalgalite::Blob.new( :string => @stmt_api.column_blob( idx ), :column => col.schema )
+              value = Amalgalite::Blob.new( :string => @stmt_api.column_blob( idx ), :column => col )
             end
           else
             raise ::Amalgalite::Error, "BUG! : Unknown SQLite column type of #{column_type}"
           end
 
-          row << db.type_map.result_value_of( col.schema.declared_data_type, value )
+          row.store_by_index(idx, db.type_map.result_value_of( col.normalized_declared_data_type, value ))
         end
-        row.fields = result_fields
       when ResultCode::DONE
-        row = nil
         write_blobs
       else
         self.close # must close so that the error message is guaranteed to be pushed into the database handler
-                   # and we can can call last_error_message on it
+                   # and we can call last_error_message on it
         msg = "SQLITE ERROR #{rc} (#{Amalgalite::SQLite3::Constants::ResultCode.name_from_value( rc )}) : #{@db.api.last_error_message}"
         raise Amalgalite::SQLite3::Error, msg
       end
@@ -326,23 +324,24 @@ module Amalgalite
     # The full meta information from the origin column is also obtained for help
     # in doing type conversion.
     #
-    # As iteration over the row meta informatio happens, record if the special
+    # As iteration over the row meta information happens, record if the special
     # "ROWID", "OID", or "_ROWID_" column is encountered.  If that column is
     # encountered then we make note of it.
     #
+    # This method cannot be called until after the @stmt_api has returne from
+    # `step` at least once
+    #
     def result_meta
       unless @result_meta
         meta = []
         column_count.times do |idx|
-          column_meta = ::OpenStruct.new
-          column_meta.name = @stmt_api.column_name( idx )
-
-          db_name  = @stmt_api.column_database_name( idx ) 
-          tbl_name = @stmt_api.column_table_name( idx ) 
-          col_name = @stmt_api.column_origin_name( idx ) 
+          as_name  = @stmt_api.column_name( idx )
+          db_name  = @stmt_api.column_database_name( idx )
+          tbl_name = @stmt_api.column_table_name( idx )
+          col_name = @stmt_api.column_origin_name( idx )
 
-          column_meta.schema = ::Amalgalite::Column.new( db_name, tbl_name, col_name, idx )
-          column_meta.schema.declared_data_type = @stmt_api.column_declared_type( idx )
+          column_meta = ::Amalgalite::Column.new( db_name, tbl_name, col_name, idx, as_name )
+          column_meta.declared_data_type = @stmt_api.column_declared_type( idx )
 
           # only check for rowid if we have a table name and it is not one of the
           # sqlite_master tables.  We could get recursion in those cases.
@@ -351,7 +350,7 @@ module Amalgalite
             @rowid_index = idx
           end
 
-          meta << column_meta 
+          meta << column_meta
         end
 
         @result_meta = meta
@@ -382,7 +381,16 @@ module Amalgalite
     # all strings
     #
     def result_fields
-      @fields ||= result_meta.collect { |m| m.name }
+      @fields ||= result_meta.collect { |m| m.as_name }
+    end
+
+    def result_field_map
+      @result_field_map ||= {}.tap do |map|
+        result_meta.each do |column|
+          map[column.as_name.to_s] = column.order
+          map[column.as_name.to_sym] = column.order
+        end
+      end
     end
 
     ##

data/lib/amalgalite/type_maps/default_map.rb

@@ -15,47 +15,42 @@ module Amalgalite::TypeMaps
   # out the best way to convert between populate SQL 'types' and ruby classes
   #
   class DefaultMap
-    class << self
-      def methods_handling_sql_types # :nodoc:
-        @methods_handling_sql_types ||= {
-          'date'      => %w[ date ],
-          'datetime'  => %w[ datetime ],
-          'time'      => %w[ timestamp time ],
-          'float'     => %w[ double float real numeric decimal ],
-          'integer'   => %w[ integer tinyint smallint int int2 int4 int8 bigint serial bigserial ],
-          'string'    => %w[ text char string varchar character json ],
-          'boolean'   => %w[ bool boolean ],
-          'blob'      => %w[ binary blob ],
-        }
-      end
+    SQL_TO_METHOD = {
+      'date'      => 'date',
+      'datetime'  => 'datetime',
+      'timestamp' => 'time',
+      'time'      => 'time',
 
-      # say what method to call to convert an sql type to a ruby type
-      #
-      def sql_to_method( sql_type  ) # :nodoc:
-        unless defined? @sql_to_method
-          @sql_to_method = {}
-          methods_handling_sql_types.each_pair do |method, sql_types|
-            sql_types.each { |t| @sql_to_method[t] = method }
-          end
-        end
-        return_method = @sql_to_method[sql_type]
-
-        # the straight lookup didn't work, try iterating through the types and
-        # see what is found
-        unless return_method
-          @sql_to_method.each_pair do |sql, method|
-            if sql_type.index(sql) then
-              return_method = method
-              break
-            end
-          end
-        end
-        return return_method
-      end
-    end
+      'double'    => 'float',
+      'float'     => 'float',
+      'real'      => 'float',
+      'numeric'   => 'float',
+      'decimal'   => 'float',
 
-    def initialize
-    end
+      'integer'   => 'integer',
+      'tinyint'   => 'integer',
+      'smallint'  => 'integer',
+      'int'       => 'integer',
+      'int2'      => 'integer',
+      'int4'      => 'integer',
+      'int8'      => 'integer',
+      'bigint'    => 'integer',
+      'serial'    => 'integer',
+      'bigserial' => 'integer',
+
+      'text'      => 'string',
+      'char'      => 'string',
+      'string'    => 'string',
+      'varchar'   => 'string',
+      'character' => 'string',
+      'json'      => 'string',
+
+      'bool'      => 'boolean',
+      'boolean'   => 'boolean',
+
+      'blob'      => 'blob',
+      'binary'    => 'blob',
+    }.freeze
 
     ##
     # A straight logical mapping (for me at least) of basic Ruby classes to SQLite types, if
@@ -79,29 +74,26 @@ module Amalgalite::TypeMaps
     ##
     # Map the incoming value to an outgoing value.  For some incoming values,
     # there will be no change, but for some (i.e. Dates and Times) there is some
-    # conversion
+    # conversion.
+    #
+    # It is assumed that `normalized_declared_type` is a downcased string. This
+    # assumption is made for performance reasons as this method is called many
+    # times during the returning of data from a query.
     #
-    def result_value_of( declared_type, value )
+    def result_value_of( normalized_declared_type, value )
       case value
-      when Numeric
-        return value
-      when NilClass
-        return value
-      when Amalgalite::Blob
+      when Numeric, NilClass, Amalgalite::Blob
         return value
       when String
-        if declared_type then
-          conversion_method = DefaultMap.sql_to_method( declared_type.downcase )
-          if conversion_method then
-            return send(conversion_method, value)  
-          else
-            raise ::Amalgalite::Error, "Unable to convert SQL type of #{declared_type} to a Ruby class"
-          end
+        return value unless normalized_declared_type
+
+        conversion_method = DefaultMap::SQL_TO_METHOD[normalized_declared_type]
+        if conversion_method then
+          return send(conversion_method, value)
         else
-          # unable to do any other conversion, just return what we have.
-          return value
+          raise ::Amalgalite::Error, "Unable to convert SQL type of #{normalized_declared_type} to a Ruby class"
         end
-      else 
+      else
         raise ::Amalgalite::Error, "Unable to convert a class #{value.class.name} with value #{value.inspect}"
       end
     end

data/lib/amalgalite/version.rb

@@ -4,5 +4,5 @@
 #++
 
 module Amalgalite
-  VERSION = "1.9.4"
+  VERSION = "2.0.0"
 end