activerecord-materialize-adapter 0.2.0 → 0.3.0

data/lib/active_record/connection_adapters/materialize/schema_definitions.rb

@@ -174,10 +174,7 @@ module ActiveRecord
         # :call-seq: xml(*names, **options)
 
         included do
-          define_column_methods :bigserial, :bit, :bit_varying, :cidr, :citext, :daterange,
-            :hstore, :inet, :interval, :int4range, :int8range, :jsonb, :ltree, :macaddr,
-            :money, :numrange, :oid, :point, :line, :lseg, :box, :path, :polygon, :circle,
-            :serial, :tsrange, :tstzrange, :tsvector, :uuid, :xml
+          define_column_methods :bigint, :bit, :bit_varying, :interval, :jsonb, :oid
         end
       end
 
@@ -194,9 +191,9 @@ module ActiveRecord
         private
           def integer_like_primary_key_type(type, options)
             if type == :bigint || options[:limit] == 8
-              :bigserial
+              :bigint
             else
-              :serial
+              :integer
             end
           end
       end

data/lib/active_record/connection_adapters/materialize/schema_dumper.rb

@@ -4,18 +4,88 @@ module ActiveRecord
   module ConnectionAdapters
     module Materialize
       class SchemaDumper < ActiveRecord::ConnectionAdapters::SchemaDumper # :nodoc:
-        private
-          def extensions(stream)
-            extensions = @connection.extensions
-            if extensions.any?
-              stream.puts "  # These are extensions that must be enabled in order to support this database"
-              extensions.sort.each do |extension|
-                stream.puts "  enable_extension #{extension.inspect}"
+        def dump(stream)
+          header(stream)
+          extensions(stream)
+          tables(stream)
+          views_and_sources(stream)
+          trailer(stream)
+          stream
+        end
+
+        def views_and_sources(stream)
+          sorted_sources = @connection.sources.sort
+          sorted_sources.each do |source_name|
+            source(source_name, stream)
+          end
+
+          # TODO sort views by dependencies
+          sorted_views = @connection.views.sort
+          sorted_views.each do |view_name|
+            view(view_name, stream)
+          end
+        end
+
+        # Create source
+        def source(source_name, stream)
+          options = @connection.source_options(source_name)
+          begin
+            src_stream = StringIO.new
+
+            src_stream.print "  create_source #{remove_prefix_and_suffix(source_name).inspect}"
+            src_stream.print ", source_type: :#{options[:source_type]}" unless options[:source_type].nil?
+            src_stream.puts ", publication: #{options[:publication].inspect}" unless options[:publication].nil?
+            src_stream.puts ", materialize: #{options[:materialize]}" unless options[:materialize].nil?
+            src_stream.puts
+
+            src_stream.rewind
+            stream.print src_stream.read
+
+          rescue StandardError => e
+            stream.puts "# Could not dump source #{source_name.inspect} because of following #{e.class}"
+            stream.puts "#   #{e.message}"
+            stream.puts
+          end
+        end
+
+        # Create view
+        def view(view_name, stream)
+          creation_query = @connection.view_sql(view_name)
+          begin
+            src_stream = StringIO.new
+            src_stream.puts "  create_view #{remove_prefix_and_suffix(view_name).inspect} do"
+
+            src_stream.puts "    <<-SQL.squish"
+            src_stream.puts "      #{creation_query}"
+            src_stream.puts "    SQL"
+
+            src_stream.puts "  end"
+            src_stream.puts
+
+            # TODO indexes
+
+            src_stream.rewind
+            stream.print src_stream.read
+
+          rescue StandardError => e
+            stream.puts "# Could not dump source #{source_name.inspect} because of following #{e.class}"
+            stream.puts "#   #{e.message}"
+            stream.puts
+          end
+        end
+
+        def indexes_in_create(table, stream)
+          if (indexes = @connection.indexes(table)).any?
+            index_statements = indexes
+              .select { |index| !index.name.include?("_primary_idx") }
+              .map do |index|
+                "    t.index #{index_parts(index).join(', ')}"
               end
-              stream.puts
-            end
+            stream.puts index_statements.sort.join("\n")
           end
+        end
 
+        private
           def prepare_column_options(column)
             spec = super
             spec[:array] = "true" if column.array?
@@ -23,26 +93,16 @@ module ActiveRecord
           end
 
           def default_primary_key?(column)
-            schema_type(column) == :bigserial
-          end
-
-          def explicit_primary_key_default?(column)
-            column.type == :uuid || (column.type == :integer && !column.serial?)
+            schema_type(column) == :bigint
           end
 
           def schema_type(column)
-            return super unless column.serial?
-
             if column.bigint?
-              :bigserial
+              :bigint
             else
-              :serial
+              super
             end
           end
-
-          def schema_expression(column)
-            super unless column.serial?
-          end
       end
     end
   end

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

@@ -40,90 +40,36 @@ module ActiveRecord
 
         # Returns true if schema exists.
         def schema_exists?(name)
-          query_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = #{quote(name)}", "SCHEMA").to_i > 0
+          schema_names.include? name.to_s
         end
 
         # Verifies existence of an index with a given name.
         def index_name_exists?(table_name, index_name)
-          table = quoted_scope(table_name)
-          index = quoted_scope(index_name)
-
-          query_value(<<~SQL, "SCHEMA").to_i > 0
-            SELECT COUNT(*)
-            FROM pg_class t
-            INNER JOIN pg_index d ON t.oid = d.indrelid
-            INNER JOIN pg_class i ON d.indexrelid = i.oid
-            LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
-            WHERE i.relkind IN ('i', 'I')
-              AND i.relname = #{index[:name]}
-              AND t.relname = #{table[:name]}
-              AND n.nspname = #{index[:schema]}
+          available_indexes = execute(<<~SQL, "SCHEMA")
+            SHOW INDEXES FROM #{quote_table_name(table_name)}
           SQL
+          available_indexes.map { |c| c['key_name'] }.include? index_name.to_s
         end
 
         # Returns an array of indexes for the given table.
         def indexes(table_name) # :nodoc:
-          scope = quoted_scope(table_name)
-
-          result = query(<<~SQL, "SCHEMA")
-            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
-                            pg_catalog.obj_description(i.oid, 'pg_class') AS comment
-            FROM pg_class t
-            INNER JOIN pg_index d ON t.oid = d.indrelid
-            INNER JOIN pg_class i ON d.indexrelid = i.oid
-            LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
-            WHERE i.relkind IN ('i', 'I')
-              AND d.indisprimary = 'f'
-              AND t.relname = #{scope[:name]}
-              AND n.nspname = #{scope[:schema]}
-            ORDER BY i.relname
+          available_indexes = execute(<<~SQL, "SCHEMA")
+            SHOW INDEXES FROM #{quote_table_name(table_name)}
           SQL
-
-          result.map do |row|
-            index_name = row[0]
-            unique = row[1]
-            indkey = row[2].split(" ").map(&:to_i)
-            inddef = row[3]
-            oid = row[4]
-            comment = row[5]
-
-            using, expressions, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: WHERE (.+))?\z/m).flatten
-
-            orders = {}
-            opclasses = {}
-
-            if indkey.include?(0)
-              columns = expressions
-            else
-              columns = Hash[query(<<~SQL, "SCHEMA")].values_at(*indkey).compact
-                SELECT a.attnum, a.attname
-                FROM pg_attribute a
-                WHERE a.attrelid = #{oid}
-                AND a.attnum IN (#{indkey.join(",")})
-              SQL
-
-              # add info on sort order (only desc order is explicitly specified, asc is the default)
-              # and non-default opclasses
-              expressions.scan(/(?<column>\w+)"?\s?(?<opclass>\w+_ops)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
-                opclasses[column] = opclass.to_sym if opclass
-                if nulls
-                  orders[column] = [desc, nulls].compact.join(" ")
-                else
-                  orders[column] = :desc if desc
-                end
-              end
-            end
-
+          available_indexes.group_by { |c| c['key_name'] }.map do |k, v|
+            index_name = k
             IndexDefinition.new(
               table_name,
               index_name,
-              unique,
-              columns,
-              orders: orders,
-              opclasses: opclasses,
-              where: where,
-              using: using.to_sym,
-              comment: comment.presence
+              unique = false,
+              columns = v.map { |c| c['column_name'] },
+              lengths: {},
+              orders: {},
+              opclasses: {},
+              where: nil,
+              type: nil,
+              using: nil,
+              comment: nil
             )
           end
         end
@@ -149,9 +95,9 @@ module ActiveRecord
           end
         end
 
-        # Returns the current database name.
+        # Unsupported current_database() use default config
         def current_database
-          query_value("SELECT current_database()", "SCHEMA")
+          @config[:database]
         end
 
         # Returns the current schema name.
@@ -159,52 +105,41 @@ module ActiveRecord
           query_value("SELECT current_schema", "SCHEMA")
         end
 
-        # Returns the current database encoding format.
+        # Get encoding of database
         def encoding
-          query_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = current_database()", "SCHEMA")
+          query_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname = #{quote(current_database)}", "SCHEMA")
         end
 
-        # Returns the current database collation.
+        # Unsupported collation
         def collation
-          query_value("SELECT datcollate FROM pg_database WHERE datname = current_database()", "SCHEMA")
+          nil
         end
 
-        # Returns the current database ctype.
+        # Get ctype
         def ctype
-          query_value("SELECT datctype FROM pg_database WHERE datname = current_database()", "SCHEMA")
+          query_value("SELECT datctype FROM pg_database WHERE datname = #{quote(current_database)}", "SCHEMA")
         end
 
         # Returns an array of schema names.
         def schema_names
           query_values(<<~SQL, "SCHEMA")
-            SELECT nspname
-              FROM pg_namespace
-             WHERE nspname !~ '^pg_.*'
-               AND nspname NOT IN ('information_schema')
-             ORDER by nspname;
+            SELECT
+              s.name
+            FROM mz_schemas s
+            LEFT JOIN mz_databases d ON s.database_id = d.id
+            WHERE
+              d.name = #{quote(current_database)}
           SQL
         end
 
         # Creates a schema for the given schema name.
         def create_schema(schema_name)
-          execute "CREATE SCHEMA #{quote_schema_name(schema_name)}"
+          execute "CREATE SCHEMA #{quote_schema_name(schema_name.to_s)}"
         end
 
         # Drops the schema for the given schema name.
         def drop_schema(schema_name, options = {})
-          execute "DROP SCHEMA#{' IF EXISTS' if options[:if_exists]} #{quote_schema_name(schema_name)} CASCADE"
-        end
-
-        # Sets the schema search path to a string of comma-separated schema names.
-        # Names beginning with $ have to be quoted (e.g. $user => '$user').
-        # See: https://www.postgresql.org/docs/current/static/ddl-schemas.html
-        #
-        # This should be not be called manually but set in database.yml.
-        def schema_search_path=(schema_csv)
-          if schema_csv
-            execute("SET search_path TO #{schema_csv}", "SCHEMA")
-            @schema_search_path = schema_csv
-          end
+          execute "DROP SCHEMA#{' IF EXISTS' if options[:if_exists]} #{quote_schema_name(schema_name.to_s)} CASCADE"
         end
 
         # Returns the active schema search path.
@@ -212,170 +147,41 @@ module ActiveRecord
           @schema_search_path ||= query_value("SHOW search_path", "SCHEMA")
         end
 
-        # Returns the current client message level.
-        def client_min_messages
-          query_value("SHOW client_min_messages", "SCHEMA")
-        end
-
-        # Set the client message level.
-        def client_min_messages=(level)
-          execute("SET client_min_messages TO '#{level}'", "SCHEMA")
-        end
-
-        # Returns the sequence name for a table's primary key or some other specified key.
+        # Returns the sequence name for compatability
         def default_sequence_name(table_name, pk = "id") #:nodoc:
-          result = serial_sequence(table_name, pk)
-          return nil unless result
-          Utils.extract_schema_qualified_name(result).to_s
-        rescue ActiveRecord::StatementInvalid
           Materialize::Name.new(nil, "#{table_name}_#{pk}_seq").to_s
         end
 
-        def serial_sequence(table, column)
-          query_value("SELECT pg_get_serial_sequence(#{quote(table)}, #{quote(column)})", "SCHEMA")
-        end
-
-        # Sets the sequence of a table's primary key to the specified value.
-        def set_pk_sequence!(table, value) #:nodoc:
-          pk, sequence = pk_and_sequence_for(table)
-
-          if pk
-            if sequence
-              quoted_sequence = quote_table_name(sequence)
-
-              query_value("SELECT setval(#{quote(quoted_sequence)}, #{value})", "SCHEMA")
-            else
-              @logger.warn "#{table} has primary key #{pk} with no default sequence." if @logger
-            end
-          end
-        end
-
-        # Resets the sequence of a table's primary key to the maximum value.
-        def reset_pk_sequence!(table, pk = nil, sequence = nil) #:nodoc:
-          unless pk && sequence
-            default_pk, default_sequence = pk_and_sequence_for(table)
-
-            pk ||= default_pk
-            sequence ||= default_sequence
-          end
-
-          if @logger && pk && !sequence
-            @logger.warn "#{table} has primary key #{pk} with no default sequence."
-          end
-
-          if pk && sequence
-            quoted_sequence = quote_table_name(sequence)
-            max_pk = query_value("SELECT MAX(#{quote_column_name pk}) FROM #{quote_table_name(table)}", "SCHEMA")
-            if max_pk.nil?
-              if database_version >= 100000
-                minvalue = query_value("SELECT seqmin FROM pg_sequence WHERE seqrelid = #{quote(quoted_sequence)}::regclass", "SCHEMA")
-              else
-                minvalue = query_value("SELECT min_value FROM #{quoted_sequence}", "SCHEMA")
-              end
-            end
-
-            query_value("SELECT setval(#{quote(quoted_sequence)}, #{max_pk ? max_pk : minvalue}, #{max_pk ? true : false})", "SCHEMA")
-          end
-        end
-
-        # Returns a table's primary key and belonging sequence.
-        def pk_and_sequence_for(table) #:nodoc:
-          # First try looking for a sequence with a dependency on the
-          # given table's primary key.
-          result = query(<<~SQL, "SCHEMA")[0]
-            SELECT attr.attname, nsp.nspname, seq.relname
-            FROM pg_class      seq,
-                 pg_attribute  attr,
-                 pg_depend     dep,
-                 pg_constraint cons,
-                 pg_namespace  nsp
-            WHERE seq.oid           = dep.objid
-              AND seq.relkind       = 'S'
-              AND attr.attrelid     = dep.refobjid
-              AND attr.attnum       = dep.refobjsubid
-              AND attr.attrelid     = cons.conrelid
-              AND attr.attnum       = cons.conkey[1]
-              AND seq.relnamespace  = nsp.oid
-              AND cons.contype      = 'p'
-              AND dep.classid       = 'pg_class'::regclass
-              AND dep.refobjid      = #{quote(quote_table_name(table))}::regclass
+        # Primary keys -  approximation
+        def primary_keys(table_name) # :nodoc:
+          available_indexes = execute(<<~SQL, "SCHEMA").group_by { |c| c['key_name'] }
+            SHOW INDEXES FROM #{quote_table_name(table_name)}
           SQL
-
-          if result.nil? || result.empty?
-            result = query(<<~SQL, "SCHEMA")[0]
-              SELECT attr.attname, nsp.nspname,
-                CASE
-                  WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
-                  WHEN split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2) ~ '.' THEN
-                    substr(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2),
-                           strpos(split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2), '.')+1)
-                  ELSE split_part(pg_get_expr(def.adbin, def.adrelid), '''', 2)
-                END
-              FROM pg_class       t
-              JOIN pg_attribute   attr ON (t.oid = attrelid)
-              JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
-              JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
-              JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
-              WHERE t.oid = #{quote(quote_table_name(table))}::regclass
-                AND cons.contype = 'p'
-                AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate'
-            SQL
-          end
-
-          pk = result.shift
-          if result.last
-            [pk, Materialize::Name.new(*result)]
+          possible_primary = available_indexes.keys.select { |c| c.include? "primary_idx" }
+          if possible_primary.size == 1
+            available_indexes[possible_primary.first].map { |c| c['column_name'] }
           else
-            [pk, nil]
+            []
           end
-        rescue
-          nil
         end
 
-        def primary_keys(table_name) # :nodoc:
-          query_values(<<~SQL, "SCHEMA")
-            SELECT a.attname
-              FROM (
-                     SELECT indrelid, indkey, generate_subscripts(indkey, 1) idx
-                       FROM pg_index
-                      WHERE indrelid = #{quote(quote_table_name(table_name))}::regclass
-                        AND indisprimary
-                   ) i
-              JOIN pg_attribute a
-                ON a.attrelid = i.indrelid
-               AND a.attnum = i.indkey[i.idx]
-             ORDER BY i.idx
-          SQL
-        end
-
-        # Renames a table.
-        # Also renames a table's primary key sequence if the sequence name exists and
-        # matches the Active Record default.
-        #
-        # Example:
-        #   rename_table('octopuses', 'octopi')
+        # Renames a table with index references
         def rename_table(table_name, new_name)
           clear_cache!
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
-          pk, seq = pk_and_sequence_for(new_name)
-          if pk
-            idx = "#{table_name}_pkey"
-            new_idx = "#{new_name}_pkey"
-            execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}"
-            if seq && seq.identifier == "#{table_name}_#{pk}_seq"
-              new_seq = "#{new_name}_#{pk}_seq"
-              execute "ALTER TABLE #{seq.quoted} RENAME TO #{quote_table_name(new_seq)}"
-            end
+          if index_name_exists?(new_name, "#{table_name}_primary_idx")
+            rename_index(new_name, "#{table_name}_primary_idx", "#{new_name}_primary_idx")
           end
           rename_table_indexes(table_name, new_name)
         end
 
+        # https://materialize.com/docs/sql/alter-rename/
         def add_column(table_name, column_name, type, **options) #:nodoc:
           clear_cache!
           super
-          change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
         end
 
+        # https://materialize.com/docs/sql/alter-rename/
         def change_column(table_name, column_name, type, options = {}) #:nodoc:
           clear_cache!
           sqls, procs = Array(change_column_for_alter(table_name, column_name, type, options)).partition { |v| v.is_a?(String) }
@@ -383,11 +189,12 @@ module ActiveRecord
           procs.each(&:call)
         end
 
-        # Changes the default value of a table column.
+        # https://materialize.com/docs/sql/alter-rename/
         def change_column_default(table_name, column_name, default_or_changes) # :nodoc:
           execute "ALTER TABLE #{quote_table_name(table_name)} #{change_column_default_for_alter(table_name, column_name, default_or_changes)}"
         end
 
+        # https://materialize.com/docs/sql/alter-rename/
         def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
           clear_cache!
           unless null || default.nil?
@@ -397,21 +204,7 @@ module ActiveRecord
           execute "ALTER TABLE #{quote_table_name(table_name)} #{change_column_null_for_alter(table_name, column_name, null, default)}"
         end
 
-        # Adds comment for given table column or drops it if +comment+ is a +nil+
-        def change_column_comment(table_name, column_name, comment_or_changes) # :nodoc:
-          clear_cache!
-          comment = extract_new_comment_value(comment_or_changes)
-          execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS #{quote(comment)}"
-        end
-
-        # Adds comment for given table or drops it if +comment+ is a +nil+
-        def change_table_comment(table_name, comment_or_changes) # :nodoc:
-          clear_cache!
-          comment = extract_new_comment_value(comment_or_changes)
-          execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}"
-        end
-
-        # Renames a column in a table.
+        # https://materialize.com/docs/sql/alter-rename/
         def rename_column(table_name, column_name, new_column_name) #:nodoc:
           clear_cache!
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
@@ -420,9 +213,7 @@ module ActiveRecord
 
         def add_index(table_name, column_name, options = {}) #:nodoc:
           index_name, index_type, index_columns_and_opclasses, index_options, index_algorithm, index_using, comment = add_index_options(table_name, column_name, **options)
-          execute("CREATE #{index_type} INDEX #{index_algorithm} #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{index_using} (#{index_columns_and_opclasses})#{index_options}").tap do
-            execute "COMMENT ON INDEX #{quote_column_name(index_name)} IS #{quote(comment)}" if comment
-          end
+          execute("CREATE INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{index_columns_and_opclasses})")
         end
 
         def remove_index(table_name, options = {}) #:nodoc:
@@ -457,78 +248,17 @@ module ActiveRecord
           execute "ALTER INDEX #{quote_column_name(old_name)} RENAME TO #{quote_table_name(new_name)}"
         end
 
-        def foreign_keys(table_name)
-          scope = quoted_scope(table_name)
-          fk_info = exec_query(<<~SQL, "SCHEMA")
-            SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid
-            FROM pg_constraint c
-            JOIN pg_class t1 ON c.conrelid = t1.oid
-            JOIN pg_class t2 ON c.confrelid = t2.oid
-            JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
-            JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
-            JOIN pg_namespace t3 ON c.connamespace = t3.oid
-            WHERE c.contype = 'f'
-              AND t1.relname = #{scope[:name]}
-              AND t3.nspname = #{scope[:schema]}
-            ORDER BY c.conname
-          SQL
-
-          fk_info.map do |row|
-            options = {
-              column: row["column"],
-              name: row["name"],
-              primary_key: row["primary_key"]
-            }
-
-            options[:on_delete] = extract_foreign_key_action(row["on_delete"])
-            options[:on_update] = extract_foreign_key_action(row["on_update"])
-            options[:validate] = row["valid"]
-
-            ForeignKeyDefinition.new(table_name, row["to_table"], options)
-          end
-        end
-
-        def foreign_tables
-          query_values(data_source_sql(type: "FOREIGN TABLE"), "SCHEMA")
-        end
-
-        def foreign_table_exists?(table_name)
-          query_values(data_source_sql(table_name, type: "FOREIGN TABLE"), "SCHEMA").any? if table_name.present?
-        end
-
         # Maps logical Rails types to Materialize-specific data types.
-        def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
-          sql = \
-            case type.to_s
-            when "binary"
-              # Materialize doesn't support limits on binary (bytea) columns.
-              # The hard limit is 1GB, because of a 32-bit size field, and TOAST.
-              case limit
-              when nil, 0..0x3fffffff; super(type)
-              else raise ArgumentError, "No binary type has byte size #{limit}. The limit on binary can be at most 1GB - 1byte."
-              end
-            when "text"
-              # Materialize doesn't support limits on text columns.
-              # The hard limit is 1GB, according to section 8.3 in the manual.
-              case limit
-              when nil, 0..0x3fffffff; super(type)
-              else raise ArgumentError, "No text type has byte size #{limit}. The limit on text can be at most 1GB - 1byte."
-              end
-            when "integer"
-              case limit
-              when 1, 2; "smallint"
-              when nil, 3, 4; "integer"
-              when 5..8; "bigint"
-              else raise ArgumentError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead."
-              end
-            else
-              super
-            end
-
-          sql = "#{sql}[]" if array && type != :primary_key
-          sql
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) # :nodoc:
+          type = type.to_sym if type
+          if native = native_database_types[type]
+            (native.is_a?(Hash) ? native[:name] : native).dup
+          else
+            type.to_s
+          end
         end
 
+        # TODO: verify same functionality as postgres
         # Materialize requires the ORDER BY columns in the select list for distinct queries, and
         # requires that the ORDER BY include the distinct column.
         def columns_for_distinct(columns, orders) #:nodoc:
@@ -536,8 +266,9 @@ module ActiveRecord
             # Convert Arel node to string
             s = visitor.compile(s) unless s.is_a?(String)
             # Remove any ASC/DESC modifiers
-            s.gsub(/\s+(?:ASC|DESC)\b/i, "")
-             .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
+            s
+              .gsub(/\s+(?:ASC|DESC)\b/i, "")
+              .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
           }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
           (order_columns << super).join(", ")
@@ -602,29 +333,22 @@ module ActiveRecord
           end
 
           def new_column_from_field(table_name, field)
-            column_name, type, default, notnull, oid, fmod, collation, comment = field
-            type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
+            column_name, type, nullable, default, comment = field
+            type_metadata = fetch_type_metadata(column_name, type)
             default_value = extract_value_from_default(default)
             default_function = extract_default_function(default_value, default)
-
-            if match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/)
-              serial = sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
-            end
-
             Materialize::Column.new(
               column_name,
               default_value,
               type_metadata,
-              !notnull,
+              nullable,
               default_function,
-              collation: collation,
-              comment: comment.presence,
-              serial: serial
+              comment: comment.presence
             )
           end
 
-          def fetch_type_metadata(column_name, sql_type, oid, fmod)
-            cast_type = get_oid_type(oid, fmod, column_name, sql_type)
+          def fetch_type_metadata(column_name, sql_type)
+            cast_type = lookup_cast_type(sql_type)
             simple_type = SqlTypeMetadata.new(
               sql_type: sql_type,
               type: cast_type.type,
@@ -632,7 +356,7 @@ module ActiveRecord
               precision: cast_type.precision,
               scale: cast_type.scale,
             )
-            Materialize::TypeMetadata.new(simple_type, oid: oid, fmod: fmod)
+            Materialize::TypeMetadata.new(simple_type)
           end
 
           def sequence_name_from_parts(table_name, column_name, suffix)
@@ -705,12 +429,34 @@ module ActiveRecord
 
           def data_source_sql(name = nil, type: nil)
             scope = quoted_scope(name, type: type)
-            scope[:type] ||= "'r','v','m','p','f'" # (r)elation/table, (v)iew, (m)aterialized view, (p)artitioned table, (f)oreign table
+            scope[:type] ||= "'table','view'"
+            sql = <<~SQL
+              SELECT
+                o.name
+              FROM mz_objects o
+              LEFT JOIN mz_schemas s ON o.schema_id = s.id
+              LEFT JOIN mz_databases d ON s.database_id = d.id
+              LEFT JOIN mz_sources src ON src.id = o.id
+              LEFT JOIN mz_indexes i ON i.on_id = o.id
+              WHERE
+                d.name = #{quote(current_database)}
+                AND s.name =  #{scope[:schema]}
+                AND o.type IN (#{scope[:type]})
+            SQL
+
+            # Sources
+            sql += " AND src.id is NULL" unless scope[:type].include? 'source'
+
+            # Find with name
+            sql += " AND o.name = #{scope[:name]}" if scope[:name]
+
+            sql += " GROUP BY o.id, o.name"
+            if type == "MATERIALIZED"
+              sql += " HAVING COUNT(i.id) > 0"
+            elsif scope[:type].include?('view')
+              sql += " HAVING COUNT(i.id) = 0"
+            end
 
-            sql = +"SELECT c.relname FROM pg_class c LEFT JOIN pg_namespace n ON n.oid = c.relnamespace"
-            sql << " WHERE n.nspname = #{scope[:schema]}"
-            sql << " AND c.relname = #{scope[:name]}" if scope[:name]
-            sql << " AND c.relkind IN (#{scope[:type]})"
             sql
           end
 
@@ -719,11 +465,13 @@ module ActiveRecord
             type = \
               case type
               when "BASE TABLE"
-                "'r','p'"
+                "'table'"
+              when "MATERIALIZED"
+                "'view'"
+              when "SOURCE"
+                "'source'"
               when "VIEW"
-                "'v','m'"
-              when "FOREIGN TABLE"
-                "'f'"
+                "'view'"
               end
             scope = {}
             scope[:schema] = schema ? quote(schema) : "ANY (current_schemas(false))"