activerecord-rdb-adapter 0.9.0 → 0.9.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83412bda25cc2862942415bea85d79d44edd3d814e70b38273f1450e8dbd5ef0
-  data.tar.gz: 1871da9ce62af55890baf5b2b35ac5b86ae889d1a66b145079bbc90c23c0ffcf
+  metadata.gz: f9d0576dbcd5a9724c79ac6ff18739649b3c4b3c38b7b5e3ac9018804a0389b6
+  data.tar.gz: 1bfd97cbeb22b5d9beba889f5d3a05cf620563e6e27b2426e01b99b35afb55be
 SHA512:
-  metadata.gz: 229f06e7089fc3933eff918d9c694ea3ce90013d99c79c9ef659764adfced8478f20afe1642871e72ba4fa6599ce97b93abe609df5ef0c8123350ed948acb730
-  data.tar.gz: 98cefd761bd85fef85e28177d8049a6fd7f9318cc223368ca6b1b5b438a33526bd46707d15a41337c8ceb85bf18d44768f52b1a866be57224c1cd45c2ac9b703
+  metadata.gz: '09e1856d986538037bf3e67c6e5b330a06a6454df046cf4579a05634e9c96a2b74401aeebf45f7ad721a78a684ca886db69289f97728871bd9598bc109f362bd'
+  data.tar.gz: 63f991b80b280a186f3bb01f911cc293970e8bc82a1b07b386164f9e5b6e0fe505c5cd711ac7c72ce5d8d18044e60d40beba4ed7c481636e144b9a8fd3889e0d

data/fb.c

@@ -152,9 +152,9 @@ static long calculate_buffsize(XSQLDA *sqlda)
 			alignment = sizeof(short);
 		}
 
-		offset = FB_ALIGN((size_t)offset, alignment);
+		offset = FB_ALIGN(offset, alignment);
 		offset += length;
-		offset = FB_ALIGN((size_t)offset, sizeof(short));
+		offset = FB_ALIGN(offset, sizeof(short));
 		offset += sizeof(short);
 	}
 
@@ -166,11 +166,11 @@ static VALUE fb_error_msg(const ISC_STATUS *isc_status)
 {
 	char msg[1024];
 	VALUE result = rb_str_new(NULL, 0);
-	const size_t suffixLen = strlen("\n");
+
 	while (fb_interpret(msg, 1024, &isc_status))
 	{
 		result = rb_str_cat(result, msg, strlen(msg));
-		result = rb_str_cat(result, "\n", suffixLen);
+		result = rb_str_cat(result, "\n", strlen("\n"));
 	}
 	return result;
 }
@@ -234,7 +234,7 @@ static VALUE fb_mkdate(struct tm *tm)
 {
 	return rb_funcall(
 		rb_cDate, rb_intern("civil"), 3,
-		INT2FIX(1900 + tm->tm_year), INT2FIX(tm->tm_mon + 1), INT2FIX(tm->tm_mday));		
+		INT2FIX(1900 + tm->tm_year), INT2FIX(tm->tm_mon + 1), INT2FIX(tm->tm_mday));
 }
 
 static int responds_like_date(VALUE obj)
@@ -466,7 +466,7 @@ static XSQLDA* sqlda_alloc(long cols)
 {
 	XSQLDA *sqlda;
 
-	sqlda = (XSQLDA*)xmalloc(XSQLDA_LENGTH((size_t)cols));
+	sqlda = (XSQLDA*)xmalloc(XSQLDA_LENGTH(cols));
 #ifdef SQLDA_CURRENT_VERSION
 	sqlda->version = SQLDA_CURRENT_VERSION;
 #else
@@ -686,6 +686,8 @@ static char* trans_parseopts(VALUE opt, long *tpb_len)
 		s++;
 	}
 
+	used = 0;
+	size = 0;
 	tpb = NULL;
 	memset((void *)check_f, 0, sizeof(check_f));
 
@@ -739,11 +741,7 @@ static char* trans_parseopts(VALUE opt, long *tpb_len)
 				check_f[target_p->position] = 1;
 			} else {
 				if (used + 1 > size) {
-					char *tmp_tpb = (char *)realloc(tpb, (size_t)(size + TPBBUFF_ALLOC));
-					if (tmp_tpb == NULL) {
-					} else {
-						tpb = tmp_tpb;
-					}
+				    tpb = (char *)realloc(tpb, size + TPBBUFF_ALLOC);
 					size += TPBBUFF_ALLOC;
 				}
 				tpb[used] = target_p->optval;
@@ -779,7 +777,7 @@ static char* trans_parseopts(VALUE opt, long *tpb_len)
 					if (*resv_p == '\0' || (ofs = strspn(resv_p, LIST_DELIMIT)) < 0) {
 						resv_p++;
 					} else {
-						resv_p = &resv_p[(size_t)ofs];
+						resv_p = &resv_p[ofs];
 						tblend_p = strpbrk(resv_p, LIST_DELIMIT);
 						if (tblend_p) {
 							tbl_len = tblend_p - resv_p;
@@ -793,7 +791,7 @@ static char* trans_parseopts(VALUE opt, long *tpb_len)
 
 						if (tbl_len > 0) {
 							if (used + tbl_len + 3 > size) {
-								tpb = (char*)xrealloc(tpb, (size_t)(size+TPBBUFF_ALLOC));
+								tpb = (char*)xrealloc(tpb, size+TPBBUFF_ALLOC);
 								size += TPBBUFF_ALLOC;
 							}
 							tpb[used+1] = (char)tbl_len;
@@ -1283,15 +1281,15 @@ static void fb_cursor_free(struct FbCursor *fb_cursor)
 
 static VALUE sql_decimal_to_bigdecimal(long long sql_data, int scale)
 {
-	int  i;
+	unsigned long i;
 	char bigdecimal_buffer[23];
-	int  bigdecimal_dot;
+	unsigned long bigdecimal_dot;
 	sprintf(bigdecimal_buffer, "%022lld", sql_data);
-	bigdecimal_dot = strlen(bigdecimal_buffer) + (size_t)scale;
+	bigdecimal_dot = strlen(bigdecimal_buffer) + scale;
 	for (i = strlen(bigdecimal_buffer); i > bigdecimal_dot; i--)
 		bigdecimal_buffer[i] = bigdecimal_buffer[i-1];
 	bigdecimal_buffer[bigdecimal_dot] = '.';
-	return rb_funcall(rb_path2class("BigDecimal"), rb_intern("new"), 1, rb_str_new2(bigdecimal_buffer));
+	return rb_funcall(rb_cObject, rb_intern("BigDecimal"), 1, rb_str_new2(bigdecimal_buffer));
 }
 
 static VALUE object_to_unscaled_bigdecimal(VALUE object, int scale)
@@ -1302,7 +1300,7 @@ static VALUE object_to_unscaled_bigdecimal(VALUE object, int scale)
 		ratio *= 10;
 	if (TYPE(object) == T_FLOAT)
 		object = rb_funcall(object, rb_intern("to_s"), 0);
-	object = rb_funcall(rb_path2class("BigDecimal"), rb_intern("new"), 1, object);
+	object = rb_funcall(rb_cObject, rb_intern("BigDecimal"), 1, object);
 	object = rb_funcall(object, rb_intern("*"), 1, LONG2NUM(ratio));
 	return rb_funcall(object, rb_intern("round"), 0);
 }
@@ -1354,36 +1352,36 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 			switch (dtp) {
 				case SQL_TEXT :
 					alignment = 1;
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = rb_obj_as_string(obj);
 					if (RSTRING_LEN(obj) > var->sqllen) {
 						rb_raise(rb_eRangeError, "CHAR overflow: %ld bytes exceeds %d byte(s) allowed.",
 							RSTRING_LEN(obj), var->sqllen);
 					}
-					memcpy(var->sqldata, RSTRING_PTR(obj), (size_t)RSTRING_LEN(obj));
+					memcpy(var->sqldata, RSTRING_PTR(obj), RSTRING_LEN(obj));
 					var->sqllen = RSTRING_LEN(obj);
 					offset += var->sqllen + 1;
 					break;
 
 				case SQL_VARYING :
 					alignment = sizeof(short);
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					vary = (VARY *)var->sqldata;
 					obj = rb_obj_as_string(obj);
 					if (RSTRING_LEN(obj) > var->sqllen) {
 						rb_raise(rb_eRangeError, "VARCHAR overflow: %ld bytes exceeds %d byte(s) allowed.",
 							RSTRING_LEN(obj), var->sqllen);
 					}
-					memcpy(vary->vary_string, RSTRING_PTR(obj), (size_t)RSTRING_LEN(obj));
+					memcpy(vary->vary_string, RSTRING_PTR(obj), RSTRING_LEN(obj));
 					vary->vary_length = RSTRING_LEN(obj);
 					offset += vary->vary_length + sizeof(short);
 					break;
 
 				case SQL_SHORT :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					if (var->sqlscale < 0) {
 						lvalue = NUM2LONG(object_to_unscaled_bigdecimal(obj, var->sqlscale));
 					} else {
@@ -1397,8 +1395,8 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					break;
 
 				case SQL_LONG :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					if (var->sqlscale < 0) {
 						lvalue = NUM2LONG(object_to_unscaled_bigdecimal(obj, var->sqlscale));
 					} else {
@@ -1412,8 +1410,8 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					break;
 
 				case SQL_FLOAT :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = double_from_obj(obj);
 					dvalue = NUM2DBL(obj);
 					if (dvalue >= 0.0) {
@@ -1429,8 +1427,8 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					break;
 
 				case SQL_DOUBLE :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = double_from_obj(obj);
 					dvalue = NUM2DBL(obj);
 					*(double *)var->sqldata = dvalue;
@@ -1438,8 +1436,8 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					break;
 
 				case SQL_INT64 :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 
 					if (var->sqlscale < 0) {
 						llvalue = NUM2LL(object_to_unscaled_bigdecimal(obj, var->sqlscale));
@@ -1452,8 +1450,8 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					break;
 
 				case SQL_BLOB :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					obj = rb_obj_as_string(obj);
 
 					blob_handle = 0;
@@ -1481,24 +1479,24 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 					break;
 
 				case SQL_TIMESTAMP :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					tm_from_timestamp(&tms, obj);
 					isc_encode_timestamp(&tms, (ISC_TIMESTAMP *)var->sqldata);
 					offset += alignment;
 					break;
 
 				case SQL_TYPE_TIME :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					tm_from_timestamp(&tms, obj);
 					isc_encode_sql_time(&tms, (ISC_TIME *)var->sqldata);
 					offset += alignment;
 					break;
 
 				case SQL_TYPE_DATE :
-					offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					tm_from_date(&tms, obj);
 					isc_encode_sql_date(&tms, (ISC_DATE *)var->sqldata);
 					offset += alignment;
@@ -1519,29 +1517,27 @@ static void fb_cursor_set_inputparams(struct FbCursor *fb_cursor, long argc, VAL
 #endif
 
 #if (FB_API_VER >= 30)
-                case SQL_BOOLEAN:
-				case blr_bool:
-				case blr_boolean:
-                    offset = FB_ALIGN((size_t)offset, alignment);
-					var->sqldata = (char *)(fb_cursor->i_buffer + (size_t)offset);
+				case SQL_BOOLEAN:
+					offset = FB_ALIGN(offset, alignment);
+					var->sqldata = (char *)(fb_cursor->i_buffer + offset);
 					*(bool *)var->sqldata = obj;
-					offset += alignment;					
-                    break;
+					offset += alignment;
+					break;
 #endif
 				default :
 					rb_raise(rb_eFbError, "Specified table includes unsupported datatype (%d)", dtp);
 			}
 
 			if (var->sqltype & 1) {
-				offset = FB_ALIGN((size_t)offset, sizeof(short));
-				var->sqlind = (short *)(fb_cursor->i_buffer + (size_t)offset);
+				offset = FB_ALIGN(offset, sizeof(short));
+				var->sqlind = (short *)(fb_cursor->i_buffer + offset);
 				*var->sqlind = 0;
 				offset += sizeof(short);
 			}
 		} else if (var->sqltype & 1) {
 			var->sqldata = 0;
-			offset = FB_ALIGN((size_t)offset, sizeof(short));
-			var->sqlind = (short *)(fb_cursor->i_buffer + (size_t)offset);
+			offset = FB_ALIGN(offset, sizeof(short));
+			var->sqlind = (short *)(fb_cursor->i_buffer + offset);
 			*var->sqlind = -1;
 			offset += sizeof(short);
 		} else {
@@ -1620,10 +1616,7 @@ static VALUE precision_from_sqlvar(XSQLVAR *sqlvar)
 		case SQL_BLOB:		return Qnil;
 		case SQL_ARRAY:		return Qnil;
 #if (FB_API_VER >= 30)
-                case SQL_BOOLEAN:
-                case blr_bool:
-                case blr_boolean:
-				return Qnil;
+		case SQL_BOOLEAN: return Qnil;
 #endif
 		case SQL_QUAD:		return Qnil;
 		case SQL_TYPE_TIME:	return Qnil;
@@ -1746,11 +1739,11 @@ static void fb_cursor_fetch_prep(struct FbCursor *fb_cursor)
 			length += sizeof(short);
 			alignment = sizeof(short);
 		}
-		offset = FB_ALIGN((size_t)offset, alignment);
-		var->sqldata = (char*)(fb_cursor->o_buffer + (size_t)offset);
+		offset = FB_ALIGN(offset, alignment);
+		var->sqldata = (char*)(fb_cursor->o_buffer + offset);
 		offset += length;
-		offset = FB_ALIGN((size_t)offset, sizeof(short));
-		var->sqlind = (short*)(fb_cursor->o_buffer + (size_t)offset);
+		offset = FB_ALIGN(offset, sizeof(short));
+		var->sqlind = (short*)(fb_cursor->o_buffer + offset);
 		offset += sizeof(short);
 	}
 }
@@ -1922,11 +1915,9 @@ static VALUE fb_cursor_fetch(struct FbCursor *fb_cursor)
 					break;
 
 #if (FB_API_VER >= 30)
-                            case SQL_BOOLEAN:
-							case blr_bool:
-							case blr_boolean:
-					val = ((*(bool*)var->sqldata) == true) ? Qtrue : Qfalse;
-                                        break;
+				case SQL_BOOLEAN:
+					val = (*(bool*)var->sqldata) ? Qtrue : Qfalse;
+					break;
 #endif
 
 				default:
@@ -2045,7 +2036,7 @@ static VALUE cursor_execute2(VALUE args)
 	if (in_params) {
 		length = calculate_buffsize(fb_cursor->i_sqlda);
 		if (length > fb_cursor->i_buffer_size) {
-			fb_cursor->i_buffer = xrealloc(fb_cursor->i_buffer, (size_t)length);
+			fb_cursor->i_buffer = xrealloc(fb_cursor->i_buffer, length);
 			fb_cursor->i_buffer_size = length;
 		}
 	}
@@ -2090,7 +2081,7 @@ static VALUE cursor_execute2(VALUE args)
 		/* Get the size of results buffer and reallocate it */
 		length = calculate_buffsize(fb_cursor->o_sqlda);
 		if (length > fb_cursor->o_buffer_size) {
-			fb_cursor->o_buffer = xrealloc(fb_cursor->o_buffer, (size_t)length);
+			fb_cursor->o_buffer = xrealloc(fb_cursor->o_buffer, length);
 			fb_cursor->o_buffer_size = length;
 		}
 
@@ -2429,10 +2420,10 @@ static char* dbp_add_string(char *dbp, char isc_dbp_code, char *s, long *length)
 	long s_len = strlen(s);
 	*length += 2 + s_len;
 	REALLOC_N(dbp, char, *length);
-	buf = dbp + (size_t)old_length;
+	buf = dbp + old_length;
 	*buf++ = isc_dbp_code;
 	*buf++ = (char)s_len;
-	memcpy(buf, s, (size_t)s_len);
+    memcpy(buf, s, s_len);
 	return dbp;
 }
 
@@ -2650,7 +2641,7 @@ static VALUE connection_columns(VALUE self, VALUE table_name)
         if (fb_connection->downcase_names && no_lowercase(name)) {
           rb_funcall(name, id_downcase_bang, 0);
         }
-        if (rb_funcall(re_rdb, match_id, 1, domain) != Qnil) {
+        if (rb_funcall(re_rdb, rb_intern("match"), 1, domain) != Qnil) {
             domain = Qnil;
         }
         if (sql_subtype == Qnil) {

data/lib/active_model/type/integer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActiveModel
+  module Type
+    class Integer < Value # :nodoc:
+      include Helpers::Numeric
+
+      DEFAULT_LIMIT = 8
+
+      def initialize(*)
+        super
+        @range = min_value...max_value
+      end
+
+      def type
+        :integer
+      end
+
+      def deserialize(value)
+        return if value.nil?
+        value.to_i
+      end
+
+      def serialize(value)
+        result = cast(value)
+        if result
+          ensure_in_range(result)
+        end
+        result
+      end
+
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
+      protected
+
+      attr_reader :range
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then 1
+        when false then 0
+        else
+          value.to_i rescue nil
+        end
+      end
+
+      def ensure_in_range(value)
+        unless range.cover?(value)
+          raise ActiveModel::RangeError, "#{value} is out of range for #{self.class} with limit #{_limit} bytes"
+        end
+      end
+
+      def max_value
+        1 << (_limit * 8 - 1) # 8 bits per byte with one bit for sign
+      end
+
+      def min_value
+        -max_value
+      end
+
+      def _limit
+        limit || DEFAULT_LIMIT
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/rdb/database_statements.rb

@@ -33,7 +33,7 @@ module ActiveRecord
             end
           end
         rescue StandardError => e
-          raise e.message.encode('UTF-8', @connection.encoding)
+          raise e
         end
 
         def explain(arel, binds = [])
@@ -93,6 +93,90 @@ module ActiveRecord
         def last_inserted_id(_result)
           nil
         end
+
+        def insert_fixtures_set(fixture_set, tables_to_delete = [])
+          fixture_inserts = fixture_set.map do |table_name, fixtures|
+            next if fixtures.empty?
+
+            build_fixture_sql(fixtures, table_name).collect {|f| f }
+          end.compact
+
+          table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name table}".dup }
+          sql = fixture_inserts.flatten(1)
+          sql.unshift(*table_deletes)
+
+          transaction(requires_new: true) do
+            sql.each do |s|
+              execute s, 'Fixture load'
+            end
+          end
+        end
+
+        private
+
+        def default_insert_value(column)
+          if column.default.nil?
+            Arel.sql('NULL')
+          else
+            Arel.sql(quote(column.default))
+          end
+        end
+
+        def build_fixture_sql(fixtures, table_name)
+          columns = schema_cache.columns_hash(table_name)
+
+          values = fixtures.map do |fixture|
+            fixture = fixture.stringify_keys
+
+            unknown_columns = fixture.keys - columns.keys
+            if unknown_columns.any?
+              raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
+            end
+
+            columns.map do |name, column|
+              if fixture.key?(name)
+                type = lookup_cast_type_from_column(column)
+                bind = Relation::QueryAttribute.new(name, fixture[name], type)
+                with_yaml_fallback(bind.value_for_database)
+              else
+                default_insert_value(column)
+              end
+            end
+          end
+
+          sql ||= []
+
+          values.each_with_index do |row, i|
+            s = ''
+            s << "INSERT INTO #{quote_table_name(table_name)}"
+
+            unless columns.empty?
+              s << ' ('
+              columns.each_with_index do |x, y|
+                s << ', ' unless y == 0
+                s << quote_column_name(x[1].name)
+              end
+              s << ')'
+            end
+
+            s << ' VALUES ('
+            row.each_with_index do |value, k|
+              s << ', ' unless k == 0
+              case value
+              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                s << value.to_s
+              when Time
+                s << quote(value.strftime("%F %T"))
+              else
+                s << quote(value).to_s
+              end
+            end
+            s << ');'
+            sql << s
+          end
+
+          sql
+        end
       end
     end
   end

data/lib/active_record/connection_adapters/rdb/schema_statements.rb

@@ -59,6 +59,7 @@ module ActiveRecord
           end
 
           return if options[:sequence] == false || !needs_sequence
+
           create_sequence(options[:sequence] || default_sequence_name(name))
           trg_sql = <<-END_SQL
             CREATE TRIGGER N$#{name.upcase} FOR #{name.upcase}
@@ -135,12 +136,13 @@ module ActiveRecord
           create_sequence(options[:sequence] || default_sequence_name(table_name)) if type == :primary_key && options[:sequence] != false
 
           return unless options[:position]
+
           # position is 1-based but add 1 to skip id column
-          execute(squish_sql(<<-end_sql))
+          execute(squish_sql(<<-END_SQL))
             ALTER TABLE #{quote_table_name(table_name)}
             ALTER COLUMN #{quote_column_name(column_name)}
             POSITION #{options[:position] + 1}
-          end_sql
+          END_SQL
         end
 
         def remove_column(table_name, column_name, type = nil, options = {})
@@ -349,6 +351,7 @@ module ActiveRecord
 
         def integer_to_sql(limit)
           return 'integer' if limit.nil?
+
           case limit
           when 1..2 then
             'smallint'
@@ -375,10 +378,10 @@ module ActiveRecord
         end
 
         def string_to_sql(limit)
-          if limit && limit > 0
+          if limit && limit > 0 && limit < 255
             "VARCHAR(#{limit})"
           else
-            'VARCHAR(150)'
+            'VARCHAR(255)'
           end
         end
 

data/lib/active_record/connection_adapters/rdb_adapter.rb

@@ -86,6 +86,10 @@ module ActiveRecord
         1499
       end
 
+      def supports_multi_insert?
+        false
+      end
+
       def active?
         return false unless @connection.open?
         # return true if @connection.transaction_started
@@ -145,6 +149,11 @@ module ActiveRecord
           ActiveRecord::RecordNotUnique.new(message)
         when /This operation is not defined for system tables/
           ActiveRecord::ActiveRecordError.new(message)
+        when /Column does not belong to referenced table/,
+            /Unsuccessful execution caused by system error that does not preclude successful execution of subsequent statements/,
+            /The cursor identified in the UPDATE or DELETE statement is not positioned on a row/,
+            /Overflow occurred during data type conversion/
+          ActiveRecord::StatementInvalid.new(message)
         else
           super
         end

data/lib/active_record/rdb_base.rb

@@ -4,6 +4,7 @@ module ActiveRecord
       require 'fb'
       config = rdb_connection_config(config)
       db = ::Fb::Database.new(config)
+      @database = db
       begin
         connection = db.connect
       rescue StandardError

data/lib/active_record/tasks/rdb_database_tasks.rb

@@ -1,24 +1,23 @@
-require 'active_record/tasks/database_tasks'
-
 module ActiveRecord
-  module Tasks
+  module Tasks # :nodoc:
     class RdbDatabaseTasks # :nodoc:
-      delegate :rdb_connection_config, :establish_connection, to: ::ActiveRecord::Base
+      delegate :rdb_connection, :rdb_connection_config, :establish_connection, to: ::ActiveRecord::Base
 
-      def initialize(configuration, root = ::ActiveRecord::Tasks::DatabaseTasks.root)
-        @root = root
+      def initialize(configuration)
         @configuration = rdb_connection_config(configuration)
       end
 
       def create
         rdb_database.create
+        # create_db
         establish_connection configuration
       rescue ::Fb::Error => e
-        raise unless e.message.include?('database or file exists')
+        raise unless e.message.include?('File exists')
         raise DatabaseAlreadyExists
       end
 
       def drop
+        establish_connection configuration
         rdb_database.drop
       rescue ::Fb::Error => e
         raise ::ActiveRecord::ConnectionNotEstablished, e.message
@@ -33,11 +32,11 @@ module ActiveRecord
         create
       end
 
-      def structure_dump(filename)
+      def structure_dump(filename, structure_dump_flags = nil)
         isql :extract, output: filename
       end
 
-      def structure_load(filename)
+      def structure_load(filename, structure_load_flags = nil)
         isql input: filename
       end
 
@@ -69,14 +68,11 @@ module ActiveRecord
       # Finds the isql command line utility from the PATH
       # Many linux distros call this program isql-fb, instead of isql
       def isql_executable
-        require 'mkmf'
-        exe = %w[isql-fb isql].detect(&method(:find_executable0))
-        exe || abort('Unable to find isql or isql-fb in your $PATH')
+        "/opt/RedDatabase/bin/isql"
       end
 
       attr_reader :configuration
 
-      attr_reader :root
     end
   end
 end

data/lib/arel/visitors/rdb_visitor.rb

@@ -3,21 +3,43 @@ module Arel
     class Rdb < Arel::Visitors::ToSql # :nodoc
       private
 
-      def visit_Arel_Nodes_SelectStatement o, collector
-        collector << "SELECT "
+      def visit_Arel_Nodes_InsertStatement(o, collector)
+        collector << "INSERT INTO "
+        collector = visit o.relation, collector
+
+        unless o.columns.empty?
+          collector << " ("
+          o.columns.each_with_index do |x, i|
+            collector << ", " unless i == 0
+            collector << quote_column_name(x.name)
+          end
+          collector << ")"
+        end
+
+        if o.values
+          maybe_visit o.values, collector
+        elsif o.select
+          maybe_visit o.select, collector
+        else
+          collector
+        end
+      end
+
+      def visit_Arel_Nodes_SelectStatement(o, collector)
+        collector << 'SELECT '
         collector = visit o.offset, collector if o.offset && !o.limit
 
-        collector = o.cores.inject(collector) {|c, x|
+        collector = o.cores.inject(collector) do |c, x|
           visit_Arel_Nodes_SelectCore(x, c)
-        }
+        end
 
         unless o.orders.empty?
           collector << ORDER_BY
           len = o.orders.length - 1
-          o.orders.each_with_index {|x, i|
+          o.orders.each_with_index do |x, i|
             collector = visit(x, collector)
             collector << COMMA unless len == i
-          }
+          end
         end
 
         if o.limit && o.offset
@@ -29,7 +51,7 @@ module Arel
         maybe_visit o.lock, collector
       end
 
-      def visit_Arel_Nodes_SelectCore o, collector
+      def visit_Arel_Nodes_SelectCore(o, collector)
         if o.set_quantifier
           collector = visit o.set_quantifier, collector
           collector << SPACE
@@ -44,7 +66,7 @@ module Arel
         end
 
         if o.source && !o.source.empty?
-          collector << " FROM "
+          collector << ' FROM '
           collector = visit o.source, collector
         end
 
@@ -69,7 +91,7 @@ module Arel
           collector = maybe_visit o.having, collector
         else
           unless o.havings.empty?
-            collector << " HAVING "
+            collector << ' HAVING '
             inject_join o.havings, collector, AND
           end
         end
@@ -77,33 +99,34 @@ module Arel
         collector
       end
 
-      def visit_Arel_Nodes_Limit o, collector
-        collector << " ROWS "
+      def visit_Arel_Nodes_Limit(o, collector)
+        collector << ' ROWS '
         visit o.expr, collector
       end
 
-      def visit_Arel_Nodes_Offset o, collector
-        collector << " SKIP "
+      def visit_Arel_Nodes_Offset(o, collector)
+        collector << ' SKIP '
         visit o.expr, collector
       end
 
       def limit_with_rows o, collector
-        o.offset.expr.value = ActiveModel::Attribute.with_cast_value("OFFSET".freeze,
+        o.offset.expr.value = ActiveModel::Attribute.with_cast_value('OFFSET'.freeze,
                                                                      o.offset.expr.value.value + 1,
                                                                      ActiveModel::Type.default_value)
         offset = o.offset.expr.value
-        o.limit.expr.value = ActiveModel::Attribute.with_cast_value("LIMIT".freeze,
-                                                                    (o.limit.expr.value.value) + (offset.value - 1),
+        o.limit.expr.value = ActiveModel::Attribute.with_cast_value('LIMIT'.freeze,
+                                                                    o.limit.expr.value.value + (offset.value - 1),
                                                                     ActiveModel::Type.default_value)
         limit = o.limit.expr.value
-        collector << " ROWS "
-        collector.add_bind(offset) {|i| "?"}
-        collector << " TO "
-        collector.add_bind(limit) {|i| "?"}
+        collector << ' ROWS '
+        collector.add_bind(offset) { |i| '?' }
+        collector << ' TO '
+        collector.add_bind(limit) { |i| '?' }
       end
 
       def quote_column_name name
         return name if Arel::Nodes::SqlLiteral === name
+
         @connection.quote_column_name(name)
       end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-rdb-adapter
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.9.4
 platform: ruby
 authors:
 - Andrey Lobanov (RedSoft)
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-06 00:00:00.000000000 Z
+date: 2019-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.1'
+        version: '5.2'
 description: ActiveRecord RedDatabase 3+ and Firebird 3+ Adapter for Rails 5+
 email: andrey.lobanov@red-soft.ru
 executables: []
@@ -35,6 +35,7 @@ files:
 - extconf.rb
 - fb.c
 - fb_extensions.rb
+- lib/active_model/type/integer.rb
 - lib/active_record/connection_adapters/rdb/database_limits.rb
 - lib/active_record/connection_adapters/rdb/database_statements.rb
 - lib/active_record/connection_adapters/rdb/quoting.rb
@@ -69,7 +70,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements:
 - Firebird library fb
-rubygems_version: 3.0.1
+rubyforge_project: 
+rubygems_version: 2.7.6.2
 signing_key: 
 specification_version: 4
 summary: ActiveRecord RedDatabase 3+ and Firebird 3+ Adapter