database-model-generator 0.6.0

data/lib/oracle/model/generator.rb

@@ -0,0 +1,287 @@
+require_relative '../../database_model_generator'
+
+begin
+  require 'oci8'
+rescue LoadError
+  # OCI8 not available - Oracle support will be disabled
+end
+
+module Oracle
+  module Model
+    class Generator < DatabaseModel::Generator::Base
+      VERSION = DatabaseModel::Generator::VERSION
+
+      private
+
+      def validate_connection(connection)
+        unless defined?(OCI8) && connection.is_a?(OCI8)
+          raise ArgumentError, "Connection must be an OCI8 object. Install 'oci8' gem for Oracle support."
+        end
+      end
+
+      def normalize_table_name(table)
+        table.upcase
+      end
+
+      def check_table_exists(table)
+        cursor = nil
+        begin
+          sql = "SELECT COUNT(*) FROM USER_TABLES WHERE TABLE_NAME = ?"
+          cursor = @connection.parse(sql)
+          cursor.bind_param(1, table.upcase)
+          cursor.exec
+          result = cursor.fetch
+          result && result[0] > 0
+        rescue => e
+          puts "Error checking table existence: #{e.message}"
+          false
+        ensure
+          cursor.close if cursor
+        end
+      end
+
+<<<<<<< Updated upstream
+      # Public method to get readable constraint information
+      def constraint_summary
+        return {} unless generated?
+
+        summary = Hash.new { |h, k| h[k] = [] }
+        @constraints.each do |constraint|
+          type = case constraint['CONSTRAINT_TYPE']
+                 when 'P' then 'Primary Key'
+                 when 'R' then 'Foreign Key'
+                 when 'U' then 'Unique'
+                 when 'C' then 'Check'
+                 else constraint['CONSTRAINT_TYPE']
+                 end
+          summary[constraint['COLUMN_NAME'].downcase] << type
+        end
+        summary
+      end
+
+      private
+
+      # Reset internal state - useful for error recovery
+      def reset_state
+        @constraints.clear
+        @primary_keys.clear
+        @foreign_keys.clear
+        @dependencies.clear
+        @belongs_to.clear
+        @column_info.clear
+        @table = nil
+        @model = nil
+        @view = nil
+      end
+
+      # Generate a more intelligent model name from table name
+      def generate_model_name(table)
+        # Handle common table naming patterns
+        name = table.split('_').map{ |part| part.downcase.capitalize }.join
+
+        # Remove trailing 's' for pluralized table names
+        name.chop! if name.length > 1 && name[-1].chr.upcase == 'S'
+
+        # Handle special cases
+        case name.downcase
+        when 'people'
+          'Person'
+        when 'children'
+          'Child'
+        when 'data'
+          'Datum'
+        else
+          name
+        end
+      end
+
+=======
+>>>>>>> Stashed changes
+      def get_column_info
+        cursor = nil
+        begin
+          if @view
+            sql = "SELECT COLUMN_NAME, DATA_TYPE, DATA_LENGTH, DATA_PRECISION, DATA_SCALE, NULLABLE
+                   FROM USER_TAB_COLUMNS WHERE TABLE_NAME = ? ORDER BY COLUMN_ID"
+          else
+            sql = "SELECT COLUMN_NAME, DATA_TYPE, DATA_LENGTH, DATA_PRECISION, DATA_SCALE, NULLABLE
+                   FROM USER_TAB_COLUMNS WHERE TABLE_NAME = ? ORDER BY COLUMN_ID"
+          end
+
+          cursor = @connection.parse(sql)
+          cursor.bind_param(1, @table)
+          cursor.exec
+
+          @column_info = []
+          while row = cursor.fetch_hash
+            @column_info << OracleColumnInfo.new(row)
+          end
+        rescue => e
+          raise "Error retrieving column information: #{e.message}"
+        ensure
+          cursor.close if cursor
+        end
+      end
+
+      def get_primary_keys
+        cursor = nil
+        begin
+          sql = "SELECT column_name FROM user_cons_columns
+                 WHERE constraint_name = (
+                   SELECT constraint_name FROM user_constraints
+                   WHERE table_name = ? AND constraint_type = 'P'
+                 ) ORDER BY position"
+
+          cursor = @connection.parse(sql)
+          cursor.bind_param(1, @table)
+          cursor.exec
+
+          @primary_keys = []
+          while row = cursor.fetch
+            @primary_keys << row[0]
+          end
+        rescue => e
+          raise "Error retrieving primary keys: #{e.message}"
+        ensure
+          cursor.close if cursor
+        end
+      end
+
+      def get_foreign_keys
+        cursor = nil
+        begin
+          sql = "SELECT column_name FROM user_cons_columns
+                 WHERE constraint_name IN (
+                   SELECT constraint_name FROM user_constraints
+                   WHERE table_name = ? AND constraint_type = 'R'
+                 )"
+
+          cursor = @connection.parse(sql)
+          cursor.bind_param(1, @table)
+          cursor.exec
+
+          @foreign_keys = []
+          while row = cursor.fetch
+            @foreign_keys << row[0]
+          end
+        rescue => e
+          raise "Error retrieving foreign keys: #{e.message}"
+        ensure
+          cursor.close if cursor
+        end
+      end
+
+      def get_constraints
+        cursor = nil
+        begin
+          sql = "SELECT c.constraint_name, c.constraint_type, cc.column_name, c.search_condition
+                 FROM user_constraints c, user_cons_columns cc
+                 WHERE c.table_name = ? AND c.constraint_name = cc.constraint_name"
+
+          cursor = @connection.parse(sql)
+          cursor.bind_param(1, @table)
+          cursor.exec
+
+          @constraints = []
+          while row = cursor.fetch_hash
+            @constraints << row
+          end
+        rescue => e
+          raise "Error retrieving constraints: #{e.message}"
+        ensure
+          cursor.close if cursor
+        end
+      end
+
+      def get_dependencies
+        cursor = nil
+        begin
+          sql = "SELECT REFERENCED_NAME as NAME, REFERENCED_TYPE as TYPE
+                 FROM USER_DEPENDENCIES WHERE NAME = ? AND TYPE = 'TABLE'"
+
+          cursor = @connection.parse(sql)
+          cursor.bind_param(1, @table)
+          cursor.exec
+
+          @dependencies = []
+          while row = cursor.fetch_hash
+            @dependencies << row
+          end
+        rescue => e
+          raise "Error retrieving dependencies: #{e.message}"
+        ensure
+          cursor.close if cursor
+        end
+      end
+
+      def format_constraint_type(constraint)
+        case constraint['CONSTRAINT_TYPE']
+        when 'P' then 'Primary Key'
+        when 'R' then 'Foreign Key'
+        when 'U' then 'Unique'
+        when 'C' then 'Check'
+        else constraint['CONSTRAINT_TYPE']
+        end
+      end
+
+      def get_constraint_column_name(constraint)
+        constraint['COLUMN_NAME']
+      end
+
+      def get_constraint_text(constraint)
+        constraint['SEARCH_CONDITION']
+      end
+
+      def is_string_type?(column)
+        column.data_type.to_s.downcase =~ /(char|varchar|varchar2|clob)/
+      end
+
+      def is_date_type?(column)
+        column.data_type.to_s.downcase =~ /(date|timestamp)/
+      end
+
+      def is_text_type?(column)
+        column.data_type.to_s.downcase =~ /(varchar|char|clob)/
+      end
+
+      def get_column_size(column)
+        column.data_size
+      end
+
+      def build_full_text_index_sql(column)
+        "CREATE INDEX idx_#{@table.downcase}_#{column.name.downcase}_text ON #{@table.upcase} (#{column.name.upcase}) INDEXTYPE IS CTXSYS.CONTEXT"
+      end
+
+      def get_full_text_index_type
+        "Oracle Text Index"
+      end
+
+      def find_fk_table(fk)
+        # Oracle-specific logic for finding referenced table
+        fk.gsub(/_id$/i, '').pluralize rescue "#{fk.gsub(/_id$/i, '')}s"
+      end
+
+      def disconnect
+        @connection.logoff if @connection
+      end
+    end
+
+    # Oracle column info wrapper
+    class OracleColumnInfo
+      attr_reader :name, :data_type, :data_size, :precision, :scale, :nullable
+
+      def initialize(row)
+        @name = row['COLUMN_NAME']
+        @data_type = row['DATA_TYPE']
+        @data_size = row['DATA_LENGTH']
+        @precision = row['DATA_PRECISION']
+        @scale = row['DATA_SCALE']
+        @nullable = row['NULLABLE'] == 'Y'
+      end
+
+      def nullable?
+        @nullable
+      end
+    end
+  end
+end

data/lib/sqlserver/model/generator.rb

@@ -0,0 +1,281 @@
+require_relative '../../database_model_generator'
+
+begin
+  require 'tiny_tds'
+rescue LoadError
+  # TinyTds not available - SQL Server support will be disabled
+end
+
+module SqlServer
+  module Model
+    class Generator < DatabaseModel::Generator::Base
+      VERSION = DatabaseModel::Generator::VERSION
+
+      private
+
+      def validate_connection(connection)
+        unless defined?(TinyTds) && connection.is_a?(TinyTds::Client)
+          raise ArgumentError, "Connection must be a TinyTds::Client object. Install 'tiny_tds' gem for SQL Server support."
+        end
+      end
+
+      def normalize_table_name(table)
+        table # SQL Server table names are case-sensitive, preserve as-is
+      end
+
+      def check_table_exists(table)
+        begin
+          sql = "SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '#{table}'"
+          result = @connection.execute(sql)
+          row = result.first
+          row && row.values.first > 0
+        rescue => e
+          puts "Error checking table existence: #{e.message}"
+          false
+        ensure
+          result.cancel if result && result.respond_to?(:cancel)
+        end
+      end
+
+      def get_column_info
+        begin
+          sql = <<~SQL
+            SELECT
+              COLUMN_NAME,
+              DATA_TYPE,
+              CHARACTER_MAXIMUM_LENGTH,
+              NUMERIC_PRECISION,
+              NUMERIC_SCALE,
+              IS_NULLABLE,
+              COLUMN_DEFAULT
+            FROM INFORMATION_SCHEMA.COLUMNS
+            WHERE TABLE_NAME = '#{@table}'
+            ORDER BY ORDINAL_POSITION
+          SQL
+
+          result = @connection.execute(sql)
+          @column_info = []
+
+          result.each do |row|
+            @column_info << SqlServerColumnInfo.new(row)
+          end
+        rescue => e
+          raise "Error retrieving column information: #{e.message}"
+        ensure
+          result.cancel if result && result.respond_to?(:cancel)
+        end
+      end
+
+      def get_primary_keys
+        begin
+          sql = <<~SQL
+            SELECT c.COLUMN_NAME
+            FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+            JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE ccu ON tc.CONSTRAINT_NAME = ccu.CONSTRAINT_NAME
+            JOIN INFORMATION_SCHEMA.COLUMNS c ON ccu.COLUMN_NAME = c.COLUMN_NAME AND ccu.TABLE_NAME = c.TABLE_NAME
+            WHERE tc.TABLE_NAME = '#{@table}' AND tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+            ORDER BY c.ORDINAL_POSITION
+          SQL
+
+          result = @connection.execute(sql)
+          @primary_keys = []
+
+          result.each do |row|
+            @primary_keys << row['COLUMN_NAME']
+          end
+        rescue => e
+          raise "Error retrieving primary keys: #{e.message}"
+        ensure
+          result.cancel if result && result.respond_to?(:cancel)
+        end
+      end
+
+      def get_foreign_keys
+        begin
+          sql = <<~SQL
+            SELECT ccu.COLUMN_NAME
+            FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+            JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE ccu ON tc.CONSTRAINT_NAME = ccu.CONSTRAINT_NAME
+            WHERE tc.TABLE_NAME = '#{@table}' AND tc.CONSTRAINT_TYPE = 'FOREIGN KEY'
+          SQL
+
+          result = @connection.execute(sql)
+          @foreign_keys = []
+
+          result.each do |row|
+            @foreign_keys << row['COLUMN_NAME']
+          end
+        rescue => e
+          raise "Error retrieving foreign keys: #{e.message}"
+        ensure
+          result.cancel if result && result.respond_to?(:cancel)
+        end
+      end
+
+      def get_constraints
+        begin
+          sql = <<~SQL
+            SELECT
+              tc.CONSTRAINT_NAME,
+              tc.CONSTRAINT_TYPE,
+              ccu.COLUMN_NAME,
+              cc.CHECK_CLAUSE
+            FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+            LEFT JOIN INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE ccu ON tc.CONSTRAINT_NAME = ccu.CONSTRAINT_NAME
+            LEFT JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc ON tc.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+            WHERE tc.TABLE_NAME = '#{@table}'
+          SQL
+
+          result = @connection.execute(sql)
+          @constraints = []
+
+          result.each do |row|
+            @constraints << {
+              'CONSTRAINT_NAME' => row['CONSTRAINT_NAME'],
+              'CONSTRAINT_TYPE' => row['CONSTRAINT_TYPE'],
+              'COLUMN_NAME' => row['COLUMN_NAME'],
+              'CHECK_CLAUSE' => row['CHECK_CLAUSE']
+            }
+          end
+        rescue => e
+          raise "Error retrieving constraints: #{e.message}"
+        ensure
+          result.cancel if result && result.respond_to?(:cancel)
+        end
+      end
+
+      def get_dependencies
+        begin
+          sql = <<~SQL
+            SELECT
+              OBJECT_NAME(referencing_id) AS NAME,
+              'TABLE' AS TYPE
+            FROM sys.sql_expression_dependencies sed
+            JOIN sys.objects o ON sed.referenced_id = o.object_id
+            WHERE o.name = '#{@table}' AND o.type = 'U'
+          SQL
+
+          result = @connection.execute(sql)
+          @dependencies = []
+
+          result.each do |row|
+            @dependencies << {
+              'NAME' => row['NAME'],
+              'TYPE' => row['TYPE']
+            }
+          end
+        rescue => e
+          # Dependencies query may fail on some SQL Server versions, continue without error
+          @dependencies = []
+        ensure
+          result.cancel if result && result.respond_to?(:cancel)
+        end
+      end
+
+      def format_constraint_type(constraint)
+        case constraint['CONSTRAINT_TYPE']
+        when 'PRIMARY KEY' then 'Primary Key'
+        when 'FOREIGN KEY' then 'Foreign Key'
+        when 'UNIQUE' then 'Unique'
+        when 'CHECK' then 'Check'
+        else constraint['CONSTRAINT_TYPE']
+        end
+      end
+
+      def get_constraint_column_name(constraint)
+        constraint['COLUMN_NAME']
+      end
+
+      def get_constraint_text(constraint)
+        constraint['CHECK_CLAUSE']
+      end
+
+      def is_string_type?(column)
+        column.data_type.downcase =~ /(char|varchar|nchar|nvarchar|text|ntext)/
+      end
+
+      def is_date_type?(column)
+        column.data_type.downcase =~ /(date|time|datetime|datetime2|smalldatetime|datetimeoffset)/
+      end
+
+      def is_text_type?(column)
+        column.data_type.downcase =~ /(varchar|nvarchar|char|nchar|text|ntext)/
+      end
+
+      def get_column_size(column)
+        column.character_maximum_length
+      end
+
+      def build_full_text_index_sql(column)
+        "CREATE FULLTEXT INDEX ON #{@table} (#{column.name.upcase}) KEY INDEX PK_#{@table}"
+      end
+
+      def get_full_text_index_type
+        "SQL Server Full-Text Index"
+      end
+
+      def find_fk_table(fk)
+        # SQL Server-specific logic for finding referenced table
+        # Try to get actual referenced table from foreign key constraints
+        begin
+          sql = <<~SQL
+            SELECT
+              OBJECT_NAME(f.referenced_object_id) AS referenced_table
+            FROM sys.foreign_keys f
+            JOIN sys.foreign_key_columns fc ON f.object_id = fc.constraint_object_id
+            JOIN sys.columns c ON fc.parent_object_id = c.object_id AND fc.parent_column_id = c.column_id
+            WHERE f.parent_object_id = OBJECT_ID('#{@table}') AND c.name = '#{fk}'
+          SQL
+
+          result = @connection.execute(sql)
+          row = result.first
+          if row && row['referenced_table']
+            return row['referenced_table'].downcase
+          end
+        rescue => e
+          # Fall back to naming convention if query fails
+        ensure
+          result.cancel if result && result.respond_to?(:cancel)
+        end
+
+        # Fallback to naming convention
+        fk.gsub(/_id$/i, '').pluralize rescue "#{fk.gsub(/_id$/i, '')}s"
+      end
+
+      def disconnect
+        @connection.close if @connection
+      end
+    end
+
+    # SQL Server column info wrapper
+    class SqlServerColumnInfo
+      attr_reader :name, :data_type, :character_maximum_length, :numeric_precision, :numeric_scale, :nullable, :column_default
+
+      def initialize(row)
+        @name = row['COLUMN_NAME']
+        @data_type = row['DATA_TYPE']
+        @character_maximum_length = row['CHARACTER_MAXIMUM_LENGTH']
+        @numeric_precision = row['NUMERIC_PRECISION']
+        @numeric_scale = row['NUMERIC_SCALE']
+        @nullable = row['IS_NULLABLE'] == 'YES'
+        @column_default = row['COLUMN_DEFAULT']
+      end
+
+      def nullable?
+        @nullable
+      end
+
+      def data_size
+        @character_maximum_length
+      end
+
+      def precision
+        @numeric_precision
+      end
+
+      def scale
+        @numeric_scale
+      end
+    end
+  end
+end