mysql2postgres 0.3.2

data/lib/mysql2psql/postgres_file_writer.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'mysql2psql/postgres_writer'
+
+class Mysql2psql
+  class PostgresFileWriter < PostgresWriter
+    def initialize(file)
+      super()
+
+      @f = File.open file, 'w+:UTF-8'
+      @f << <<~SQL_HEADER
+        -- MySQL 2 PostgreSQL dump\n
+        SET client_encoding = 'UTF8';
+        SET standard_conforming_strings = off;
+        SET check_function_bodies = false;
+        SET client_min_messages = warning;
+
+      SQL_HEADER
+    end
+
+    def truncate(table)
+      serial_key = nil
+      maxval = nil
+
+      table.columns.map do |column|
+        if column[:auto_increment]
+          serial_key = column[:name]
+          maxval = column[:maxval].to_i < 1 ? 1 : column[:maxval] + 1
+        end
+      end
+
+      @f << <<~SQL_TRUNCATE
+        -- TRUNCATE #{table.name};
+        TRUNCATE #{PG::Connection.quote_ident table.name} CASCADE;
+
+      SQL_TRUNCATE
+
+      return unless serial_key
+
+      @f << <<~SQL_SERIAL
+        SELECT pg_catalog.setval(pg_get_serial_sequence('#{table.name}', '#{serial_key}'), #{maxval}, true);
+      SQL_SERIAL
+    end
+
+    def write_table(table)
+      primary_keys = []
+      serial_key = nil
+      maxval = nil
+
+      columns = table.columns.map do |column|
+        if column[:auto_increment]
+          serial_key = column[:name]
+          maxval = column[:maxval].to_i < 1 ? 1 : column[:maxval] + 1
+        end
+        primary_keys << column[:name] if column[:primary_key]
+        "  #{column_description column}"
+      end.join(",\n")
+
+      if serial_key
+        @f << <<~SQL_SEQUENCE
+          --
+          -- Name: #{table.name}_#{serial_key}_seq; Type: SEQUENCE; Schema: public
+          --
+
+          DROP SEQUENCE IF EXISTS #{table.name}_#{serial_key}_seq CASCADE;
+
+          CREATE SEQUENCE #{table.name}_#{serial_key}_seq
+              INCREMENT BY 1
+              NO MAXVALUE
+              NO MINVALUE
+              CACHE 1;
+
+
+          SELECT pg_catalog.setval('#{table.name}_#{serial_key}_seq', #{maxval}, true);
+
+        SQL_SEQUENCE
+      end
+
+      @f << <<~SQL_TABLE
+        -- Table: #{table.name}
+
+        -- DROP TABLE #{table.name};
+        DROP TABLE IF EXISTS #{PG::Connection.quote_ident table.name} CASCADE;
+
+        CREATE TABLE #{PG::Connection.quote_ident table.name} (
+      SQL_TABLE
+
+      @f << columns
+
+      if (primary_index = table.indexes.find { |index| index[:primary] })
+        @f << ",\n  CONSTRAINT #{table.name}_pkey PRIMARY KEY(#{primary_index[:columns].map { |col| PG::Connection.quote_ident(col) }.join(', ')})"
+      end
+
+      @f << <<~SQL_OIDS
+        \n)
+        WITHOUT OIDS;
+      SQL_OIDS
+
+      table.indexes.each do |index|
+        next if index[:primary]
+
+        unique = index[:unique] ? 'UNIQUE ' : nil
+        @f << <<~SQL_INDEX
+          DROP INDEX IF EXISTS #{PG::Connection.quote_ident index[:name]} CASCADE;
+          CREATE #{unique}INDEX #{PG::Connection.quote_ident index[:name]}
+          ON #{PG::Connection.quote_ident table.name} (#{index[:columns].map { |col| PG::Connection.quote_ident(col) }.join(', ')});
+        SQL_INDEX
+      end
+    end
+
+    def write_indexes(_table); end
+
+    def write_constraints(table)
+      table.foreign_keys.each do |key|
+        @f << "ALTER TABLE #{PG::Connection.quote_ident table.name} " \
+              "ADD FOREIGN KEY (#{key[:column].map { |c| PG::Connection.quote_ident(c) }.join(', ')}) " \
+              "REFERENCES #{PG::Connection.quote_ident key[:ref_table]}(#{key[:ref_column].map { |c| PG::Connection.quote_ident(c) }.join(', ')}) " \
+              "ON UPDATE #{key[:on_update]} ON DELETE #{key[:on_delete]};\n"
+      end
+    end
+
+    def write_contents(table, reader)
+      @f << <<~SQL_COPY
+        --
+        -- Data for Name: #{table.name}; Type: TABLE DATA; Schema: public
+        --
+
+        COPY "#{table.name}" (#{table.columns.map { |column| PG::Connection.quote_ident(column[:name]) }.join(', ')}) FROM stdin;
+      SQL_COPY
+
+      reader.paginated_read table, 1000 do |row, _counter|
+        process_row table, row
+        @f << row.join("\t")
+        @f << "\n"
+      end
+      @f << "\\.\n\n"
+    end
+
+    def close
+      @f.close
+    end
+  end
+end

data/lib/mysql2psql/postgres_writer.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'zlib'
+require 'mysql2psql/writer'
+
+class Mysql2psql
+  class PostgresWriter < Writer
+    def column_description(column)
+      "#{PG::Connection.quote_ident column[:name]} #{column_type_info column}"
+    end
+
+    def column_type(column)
+      column_type_info(column).split.first
+    end
+
+    def column_type_info(column)
+      return "integer DEFAULT nextval('#{column[:table_name]}_#{column[:name]}_seq'::regclass) NOT NULL" if column[:auto_increment]
+
+      default = if column[:default]
+                  " DEFAULT #{column[:default].nil? ? 'NULL' : "'#{PG::Connection.escape column[:default]}'"}"
+                end
+      null = column[:null] ? '' : ' NOT NULL'
+      type = case column[:type]
+             # String types
+             when 'char'
+               default += '::char' if default
+               "character(#{column[:length]})"
+             when 'varchar'
+               default += '::character varying' if default
+               "character varying(#{column[:length]})"
+             # Integer and numeric types
+             when 'integer'
+               default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_i}" if default
+               'integer'
+             when 'bigint'
+               default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_i}" if default
+               'bigint'
+             when 'tinyint'
+               default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_i}" if default
+               'smallint'
+             when 'boolean'
+               default = " DEFAULT #{column[:default].to_i == 1 ? 'true' : 'false'}" if default
+               'boolean'
+             when 'float', 'float unsigned'
+               default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default].to_f}" if default
+               'real'
+             when 'decimal'
+               default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default]}" if default
+               "numeric(#{column[:length] || 10}, #{column[:decimals] || 0})"
+             when 'double precision'
+               default = " DEFAULT #{column[:default].nil? ? 'NULL' : column[:default]}" if default
+               'double precision'
+             when 'datetime'
+               default = nil
+               'timestamp without time zone'
+             when 'date'
+               default = nil
+               'date'
+             when 'timestamp'
+               default = ' DEFAULT CURRENT_TIMESTAMP' if column[:default] == 'CURRENT_TIMESTAMP'
+               default = " DEFAULT '1970-01-01 00:00'" if column[:default] == '0000-00-00 00:00'
+               default = " DEFAULT '1970-01-01 00:00:00'" if column[:default] == '0000-00-00 00:00:00'
+               'timestamp without time zone'
+             when 'time'
+               default = ' DEFAULT NOW()' if default
+               'time without time zone'
+             when 'blob', 'longblob', 'mediumblob', 'tinyblob', 'varbinary'
+               'bytea'
+             when 'text', 'tinytext', 'mediumtext', 'longtext'
+               'text'
+             when /^enum/
+               default += '::character varying' if default
+               enum = column[:type].gsub(/enum|\(|\)/, '')
+               max_enum_size = enum.split(',').map { |check| check.size - 2 }.max
+               "character varying(#{max_enum_size}) check( \"#{column[:name]}\" in (#{enum}))"
+             when 'geometry', 'multipolygon'
+               'geometry'
+             else
+               puts "Unknown #{column.inspect}"
+               column[:type].inspect
+               return ''
+             end
+
+      "#{type}#{default}#{null}"
+    end
+
+    def process_row(table, row)
+      table.columns.each_with_index do |column, index|
+        row[index] = Time.at(row[index]).utc.strftime('%H:%M:%S') if column[:type] == 'time' && row[index]
+
+        if row[index].is_a? Time
+          row[index] = row[index].to_s.gsub '0000-00-00 00:00', '1970-01-01 00:00'
+          row[index] = row[index].to_s.gsub '0000-00-00 00:00:00', '1970-01-01 00:00:00'
+        end
+
+        if column_type(column) == 'boolean'
+          row[index] = if row[index] == 1
+                         't'
+                       else
+                         row[index].zero? ? 'f' : row[index]
+                       end
+        end
+
+        if row[index].is_a? String
+          row[index] = if column_type(column) == 'bytea'
+                         if column[:name] == 'data'
+                           with_gzip = false
+                           table.columns.each_with_index do |column_data, index_data|
+                             if column_data[:name] == 'compression' && row[index_data] == 'gzip'
+                               with_gzip = true
+                               break
+                             end
+                           end
+                           if with_gzip
+                             PG::Connection.escape_bytea(Zlib::Inflate.inflate(row[index])).gsub(/\\/, '\\\\\\').gsub(/''/, "'")
+                           else
+                             PG::Connection.escape_bytea(row[index]).gsub(/\\/, '\\\\\\').gsub(/''/, "'")
+                           end
+                         else
+                           PG::Connection.escape_bytea(row[index]).gsub(/\\/, '\\\\\\').gsub(/''/, "'")
+                         end
+                       else
+                         row[index].gsub(/\\/, '\\\\\\').gsub(/\n/, '\n').gsub(/\t/, '\t').gsub(/\r/, '\r').gsub(/\0/, '')
+                       end
+        end
+
+        row[index] = '\N' unless row[index]
+      end
+    end
+
+    def truncate(_table) end
+  end
+end

data/lib/mysql2psql/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Mysql2psql
+  VERSION = '0.3.2'
+end

data/lib/mysql2psql/writer.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class Mysql2psql
+  class Writer
+    def inload
+      raise "Method 'inload' needs to be overridden..."
+    end
+  end
+end

data/lib/mysql2psql.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'pg'
+require 'pg_ext'
+require 'pg/exceptions'
+require 'pg/constants'
+require 'pg/connection'
+require 'pg/result'
+
+require 'mysql2psql/version'
+require 'mysql2psql/converter'
+require 'mysql2psql/mysql_reader'
+require 'mysql2psql/writer'
+require 'mysql2psql/postgres_writer'
+require 'mysql2psql/postgres_file_writer'
+require 'mysql2psql/postgres_db_writer'
+
+require 'debug' if ENV.fetch('ENABLE_DEBUG', nil) == '1'
+
+class Mysql2psql
+  attr_reader :options, :reader, :writer
+
+  def initialize(yaml)
+    @options = build_options yaml
+  end
+
+  def build_options(yaml)
+    yaml.transform_keys(&:to_sym).tap do |opts|
+      opts[:mysql].transform_keys!(&:to_sym)
+      opts[:destination].transform_keys!(&:to_sym)
+      opts[:destination].each do |env, settings|
+        opts[:destination][env] = settings.transform_keys(&:to_sym)
+      end
+    end
+  end
+
+  def send_file_to_postgres(path)
+    connection = Connection.new options
+    connection.load_file path
+  end
+
+  def convert
+    @reader = MysqlReader.new options
+
+    tag = Time.new.strftime '%Y%m%d-%H%M%S'
+
+    path = './'
+    path = options[:dump_file_directory] if options[:dump_file_directory]
+
+    filename = File.expand_path File.join(path, "output_#{tag}.sql")
+    puts "Dumpfile: #{filename}"
+
+    @writer = PostgresDbWriter.new filename, options
+
+    Converter.new(reader, writer, options).convert
+
+    File.delete filename if options[:remove_dump_file] && File.exist?(filename)
+  end
+end

data/mysql2postgres.gemspec

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+lib = File.expand_path '../lib', __FILE__
+puts lib
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include? lib
+require 'mysql2psql/version'
+
+Gem::Specification.new do |s|
+  s.name = 'mysql2postgres'
+  s.version = Mysql2psql::VERSION
+  s.licenses = ['MIT']
+
+  s.authors = [
+    'Max Lapshin <max@maxidoors.ru>',
+    'Anton Ageev <anton@ageev.name>',
+    'Samuel Tribehou <cracoucax@gmail.com>',
+    'Marco Nenciarini <marco.nenciarini@devise.it>',
+    'James Nobis <jnobis@jnobis.controldocs.com>',
+    'quel <github@quelrod.net>',
+    'Holger Amann <keeney@fehu.org>',
+    'Maxim Dobriakov <closer.main@gmail.com>',
+    'Michael Kimsal <mgkimsal@gmail.com>',
+    'Jacob Coby <jcoby@portallabs.com>',
+    'Neszt Tibor <neszt@tvnetwork.hu>',
+    'Miroslav Kratochvil <exa.exa@gmail.com>',
+    'Paul Gallagher <gallagher.paul@gmail.com>',
+    'Alex C Jokela <ajokela@umn.edu>',
+    'Peter Clark <pclark@umn.edu>',
+    'Juga Paazmaya <olavic@gmail.com>',
+    'Alexander Meindl <a.meindl@alphanodes.com'
+  ]
+  s.description = 'Translates MySQL -> PostgreSQL'
+  s.email = 'a.meindl@alphanodes.com'
+  s.metadata = { 'rubygems_mfa_required' => 'true' }
+  s.executables = ['mysql2psql']
+  s.required_ruby_version = '>= 2.7'
+
+  s.files = [
+    '.gitignore',
+    'MIT-LICENSE',
+    'README.md',
+    'Rakefile',
+    'bin/mysql2psql',
+    'lib/mysql2psql.rb',
+    'lib/mysql2psql/converter.rb',
+    'lib/mysql2psql/connection.rb',
+    'lib/mysql2psql/mysql_reader.rb',
+    'lib/mysql2psql/postgres_db_writer.rb',
+    'lib/mysql2psql/postgres_file_writer.rb',
+    'lib/mysql2psql/postgres_db_writer.rb',
+    'lib/mysql2psql/postgres_writer.rb',
+    'lib/mysql2psql/version.rb',
+    'lib/mysql2psql/writer.rb',
+    'mysql2postgres.gemspec',
+    'test/fixtures/config_all_options.yml',
+    'test/fixtures/seed_integration_tests.sql',
+    'test/integration/convert_to_db_test.rb',
+    'test/integration/convert_to_file_test.rb',
+    'test/integration/converter_test.rb',
+    'test/integration/mysql_reader_base_test.rb',
+    'test/integration/mysql_reader_test.rb',
+    'test/integration/postgres_db_writer_base_test.rb',
+    'test/units/option_test.rb',
+    'test/units/postgres_file_writer_test.rb',
+    'test/test_helper.rb'
+  ]
+  s.homepage = 'https://code.alphanodes.com/alphanodes/mysql2psql'
+  s.rdoc_options = ['--charset=UTF-8']
+  s.require_paths = ['lib']
+  s.summary = 'MySQL to PostgreSQL Data Translation'
+
+  s.add_dependency 'rake'
+  s.add_runtime_dependency 'pg', '~> 1.2.2'
+  s.add_runtime_dependency 'postgres-pr', '~> 0.7'
+  s.add_runtime_dependency 'ruby-mysql', '~> 3.0'
+  s.add_development_dependency 'debug'
+  s.add_development_dependency 'rubocop-minitest'
+  s.add_development_dependency 'rubocop-performance'
+  s.add_development_dependency 'test-unit', '~> 3.5.3'
+end

data/test/fixtures/config_all_options.yml

@@ -0,0 +1,39 @@
+mysql:
+  hostname: localhost
+  port: 3306
+  socket: /tmp/mysql.sock
+  username: somename
+  password: secretpassword
+  database: somename
+
+
+destination:
+  # if file is given, output goes to file, else postgres
+  file: somefile
+  test:
+    hostname: localhost
+    port: 5432
+    username: somename
+    password: secretpassword
+    database: somename
+
+# if tables is given, only the listed tables will be converted.  leave empty to convert all tables.
+tables:
+- table1
+- table2
+- table3
+- table4
+
+# if exclude_tables is given, exclude the listed tables from the conversion.
+exclude_tables:
+- table5
+- table6
+
+# if suppress_data is true, only the schema definition will be exported/migrated, and not the data
+suppress_data: true
+
+# if suppress_ddl is true, only the data will be exported/imported, and not the schema
+suppress_ddl: false
+
+# if force_truncate is true, forces a table truncate before table loading
+force_truncate: false

data/test/fixtures/seed_integration_tests.sql

@@ -0,0 +1,24 @@
+-- seed data for integration tests
+
+DROP TABLE IF EXISTS numeric_types_basics;
+CREATE TABLE numeric_types_basics (
+  id int,
+	f_tinyint TINYINT,
+	f_smallint SMALLINT,
+	f_mediumint MEDIUMINT,
+	f_int INT,
+	f_integer INTEGER,
+	f_bigint BIGINT,
+	f_real REAL,
+	f_double DOUBLE,
+	f_float FLOAT,
+	f_decimal DECIMAL,
+	f_numeric NUMERIC
+);
+
+INSERT INTO numeric_types_basics VALUES
+(1,1,1,1,1,1,1,1,1,1,1,1),
+(2,2,2,2,2,2,2,2,2,2,2,2),
+(23,23,23,23,23,23,23,23,23,23,23,23);
+
+

data/test/integration/convert_to_db_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require File.expand_path '../test_helper', __dir__
+
+class ConvertToDbTest < Test::Unit::TestCase
+  class << self
+    def startup
+      seed_test_database
+      @options = get_test_config_by_label :localmysql_to_db_convert_all
+      @mysql2psql = Mysql2psql.new @options
+      @mysql2psql.convert
+      @mysql2psql.writer.open
+    end
+
+    def shutdown
+      @@mysql2psql.writer.close
+    end
+  end
+
+  def test_table_creation
+    assert_true @mysql2psql.writer.exists?('numeric_types_basics')
+  end
+end

data/test/integration/convert_to_file_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require File.expand_path '../test_helper', __dir__
+
+class ConvertToFileTest < Test::Unit::TestCase
+  class << self
+    def startup
+      seed_test_database
+      @options = get_test_config_by_label :localmysql_to_file_convert_all
+      @mysql2psql = Mysql2psql.new @options
+      @mysql2psql.convert
+      @content = File.read @mysql2psql.options[:destfile]
+    end
+  end
+
+  def content
+    @@content
+  end
+
+  def test_table_creation
+    assert_not_nil content.match('DROP TABLE IF EXISTS "numeric_types_basics" CASCADE')
+    assert_not_nil content.include?('CREATE TABLE "numeric_types_basics"')
+  end
+
+  def test_basic_numerics_tinyint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_tinyint" smallint,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_smallint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_smallint" integer,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_mediumint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_mediumint" integer,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_int
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_int" integer,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_integer
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_integer" integer,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_bigint
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_bigint" bigint,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_real
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_real" double precision,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_double
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_double" double precision,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_float
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_float" double precision,.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_decimal
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_decimal" numeric\(10, 0\),.*\)', Regexp::MULTILINE).match(content)
+  end
+
+  def test_basic_numerics_numeric
+    assert_not_nil Regexp.new('CREATE TABLE "numeric_types_basics".*"f_numeric" numeric\(10, 0\)[\w\n]*\)', Regexp::MULTILINE).match(content)
+  end
+end

data/test/integration/converter_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require File.expand_path '../test_helper', __dir__
+
+class ConverterTest < Test::Unit::TestCase
+  class << self
+    def startup
+      seed_test_database
+      @options = get_test_config_by_label :localmysql_to_file_convert_nothing
+    end
+  end
+
+  def test_new_converter
+    assert_nothing_raised do
+      reader = get_test_reader @options
+      writer = get_test_file_writer @options
+      converter = Mysql2psql::Converter.new reader, writer, @options
+      assert_equal 0, converter.convert
+    end
+  end
+end

data/test/integration/mysql_reader_base_test.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require File.expand_path '../test_helper', __dir__
+
+class MysqlReaderBaseTest < Test::Unit::TestCase
+  class << self
+    def startup
+      seed_test_database
+      @options = get_test_config_by_label :localmysql_to_file_convert_nothing
+    end
+  end
+
+  def test_mysql_connection
+    assert_nothing_raised do
+      Mysql2psql::MysqlReader.new @options
+    end
+  end
+
+  def test_mysql_reconnect
+    assert_nothing_raised do
+      reader = Mysql2psql::MysqlReader.new @options
+      reader.reconnect
+    end
+  end
+
+  def test_mysql_connection_without_port
+    assert_nothing_raised do
+      @options[:mysql][:port] = ''
+      @options[:mysql][:socket] = ''
+      Mysql2psql::MysqlReader.new @options
+    end
+  end
+end

data/test/integration/mysql_reader_test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require File.expand_path '../test_helper', __dir__
+
+class MysqlReaderTest < Test::Unit::TestCase
+  class << self
+    def startup
+      seed_test_database
+      @options = get_test_config_by_label :localmysql_to_file_convert_nothing
+      @reader = get_test_reader @options
+    end
+  end
+
+  def test_db_connection
+    assert_nothing_raised do
+      @reader.mysql.ping
+    end
+  end
+
+  def test_tables_collection
+    values = @reader.tables.select { |t| t.name == 'numeric_types_basics' }
+    assert_true values.length == 1
+    assert_equal 'numeric_types_basics', values[0].name
+  end
+
+  def test_paginated_read
+    expected_rows = 3
+    page_size = 2
+    expected_pages = (1.0 * expected_rows / page_size).ceil
+
+    row_count = my_row_count = 0
+    table = @reader.tables.find { |t| t.name == 'numeric_types_basics' }
+    @reader.paginated_read table, page_size do |_row, counter|
+      row_count = counter
+      my_row_count += 1
+    end
+    assert_equal expected_rows, row_count
+    assert_equal expected_rows, my_row_count
+  end
+end