tina4ruby 3.10.54 → 3.10.55

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f97899d98f7c34c914f158fc57c2b0253b79e544ad9feacdca10d6a6479209f
-  data.tar.gz: 8370cfeefc28525f4cd918543e51e5f444c7da5845c80e58c2dc548d513f26de
+  metadata.gz: 25b4d9017318ffe796da35f53d7865bd5ce5cad601a25d6dbffa512c649cd019
+  data.tar.gz: 6ee84f47f431b714ff0b4ac84ff606c3406ca5e2896d17a0835b98f23ac9385f
 SHA512:
-  metadata.gz: dde7f333c0474ff7add07c7693ebbb27b8a11d565f6f031ee0aeee106cd46e3e696a70bed388ceeebd40640b7022eb68e7e12aee55668a8914c3d5ac205cee0b
-  data.tar.gz: 0da6d2ab9ea1bb916f305f5f1dc2426dd92e1a54b3ac601c5b9cc607587ca64e7b40e0141e9cee6d7889bf001647c35b52ba2d19441027fe14bba2727d53f235
+  metadata.gz: eb0387a9321fb64193433c5d975bce3f7cfb2d25af20dcf9786cf361f6471cfecbbecad9a026e60f95f34446aa1fef65d77d93d19acb14ca7b1b6e615924cbb4
+  data.tar.gz: 73a21f6cd92dda7b2a747d824b68685e827d87b4e42ae92fb2313e69af5fef4e3704e7bca70674045ed5f149926ff4a9fc2ae8a1de2ea2a6bd41e70d4de14aa6

data/lib/tina4/auto_crud.rb

@@ -55,8 +55,10 @@ module Tina4
         # GET /api/{table} -- list all with pagination, filtering, sorting
         Tina4::Router.add_route("GET", "#{prefix}/#{table}", proc { |req, res|
           begin
-            limit = (req.query["limit"] || 10).to_i
-            offset = (req.query["offset"] || 0).to_i
+            per_page = (req.query["per_page"] || req.query["limit"] || 10).to_i
+            page     = (req.query["page"] || 1).to_i
+            limit    = per_page
+            offset   = req.query["offset"] ? req.query["offset"].to_i : (page - 1) * per_page
             order_by = parse_sort(req.query["sort"])
 
             # Filter support: ?filter[field]=value

data/lib/tina4/database.rb

@@ -76,7 +76,10 @@ module Tina4
       "mysql" => "Tina4::Drivers::MysqlDriver",
       "mssql" => "Tina4::Drivers::MssqlDriver",
       "sqlserver" => "Tina4::Drivers::MssqlDriver",
-      "firebird" => "Tina4::Drivers::FirebirdDriver"
+      "firebird" => "Tina4::Drivers::FirebirdDriver",
+      "mongodb" => "Tina4::Drivers::MongodbDriver",
+      "mongo" => "Tina4::Drivers::MongodbDriver",
+      "odbc" => "Tina4::Drivers::OdbcDriver"
     }.freeze
 
     def initialize(connection_string = nil, username: nil, password: nil, driver_name: nil, pool: 0)
@@ -491,6 +494,10 @@ module Tina4
         "mssql"
       when /firebird/, /\.fdb$/
         "firebird"
+      when /mongodb/, /^mongo:/
+        "mongodb"
+      when /^odbc:/
+        "odbc"
       else
         "sqlite"
       end

data/lib/tina4/database_result.rb

@@ -86,10 +86,15 @@ module Tina4
       slice_offset = (page - 1) * per_page
       page_records = @records[slice_offset, per_page] || []
       {
+        records: page_records,
         data: page_records,
+        count: total,
+        total: total,
+        limit: per_page,
+        offset: (page - 1) * per_page,
         page: page,
         per_page: per_page,
-        total: total,
+        totalPages: total_pages,
         total_pages: total_pages,
         has_next: page < total_pages,
         has_prev: page > 1

data/lib/tina4/drivers/mongodb_driver.rb

@@ -0,0 +1,561 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Drivers
+    class MongodbDriver
+      attr_reader :connection, :db
+
+      def connect(connection_string, username: nil, password: nil)
+        begin
+          require "mongo"
+        rescue LoadError
+          raise LoadError,
+            "The 'mongo' gem is required for MongoDB connections. " \
+            "Install: gem install mongo"
+        end
+
+        uri = build_uri(connection_string, username, password)
+        @db_name = extract_db_name(connection_string)
+        @client = Mongo::Client.new(uri)
+        @db = @client.use(@db_name)
+        @connection = @db
+        @last_insert_id = nil
+      end
+
+      def close
+        @client&.close
+        @client = nil
+        @db = nil
+        @connection = nil
+      end
+
+      # Execute a query (SELECT-like) and return array of symbol-keyed hashes
+      def execute_query(sql, params = [])
+        parsed = parse_sql(sql, params)
+        collection = @db[parsed[:collection]]
+
+        case parsed[:operation]
+        when :find
+          cursor = collection.find(parsed[:filter] || {})
+          cursor = cursor.projection(parsed[:projection]) if parsed[:projection] && !parsed[:projection].empty?
+          cursor = cursor.sort(parsed[:sort]) if parsed[:sort] && !parsed[:sort].empty?
+          cursor = cursor.skip(parsed[:skip]) if parsed[:skip] && parsed[:skip] > 0
+          cursor = cursor.limit(parsed[:limit]) if parsed[:limit] && parsed[:limit] > 0
+          cursor.map { |doc| mongo_doc_to_hash(doc) }
+        else
+          []
+        end
+      end
+
+      # Execute a DML statement (INSERT, UPDATE, DELETE, CREATE)
+      def execute(sql, params = [])
+        parsed = parse_sql(sql, params)
+        collection = @db[parsed[:collection]]
+
+        case parsed[:operation]
+        when :insert
+          result = collection.insert_one(parsed[:document])
+          @last_insert_id = result.inserted_id.to_s
+          result
+        when :update
+          collection.update_many(parsed[:filter] || {}, { "$set" => parsed[:updates] })
+        when :delete
+          collection.delete_many(parsed[:filter] || {})
+        when :create_collection
+          begin
+            @db.command(create: parsed[:collection].to_s)
+          rescue Mongo::Error::OperationFailure
+            # Collection already exists — ignore
+          end
+          nil
+        when :find
+          execute_query(sql, params)
+        else
+          nil
+        end
+      end
+
+      def last_insert_id
+        @last_insert_id
+      end
+
+      def placeholder
+        "?"
+      end
+
+      def placeholders(count)
+        (["?"] * count).join(", ")
+      end
+
+      # MongoDB has no LIMIT clause — ignore; already handled in execute_query
+      def apply_limit(sql, limit, offset = 0)
+        sql_up = sql.upcase
+        return sql if sql_up.include?("LIMIT")
+        modified = sql.dup
+        modified += " LIMIT #{limit}" if limit && limit > 0
+        modified += " OFFSET #{offset}" if offset && offset > 0
+        modified
+      end
+
+      # MongoDB transactions require a replica set — wrap in session if available
+      def begin_transaction
+        # no-op for standalone; transaction support via session handled externally
+      end
+
+      def commit
+        # no-op
+      end
+
+      def rollback
+        # no-op
+      end
+
+      def tables
+        @db.collection_names.reject { |n| n.start_with?("system.") }
+      end
+
+      def columns(table_name)
+        collection = @db[table_name.to_s]
+        sample = collection.find.limit(1).first
+        return [] unless sample
+
+        sample.keys.map do |key|
+          {
+            name: key,
+            type: sample[key].class.name,
+            nullable: true,
+            default: nil,
+            primary_key: key == "_id"
+          }
+        end
+      end
+
+      private
+
+      def build_uri(connection_string, username, password)
+        uri = connection_string.to_s
+        # Normalise scheme: mongodb:// stays, mongo:// becomes mongodb://
+        uri = uri.sub(/^mongo:\/\//, "mongodb://")
+
+        if username || password
+          # Inject credentials into the URI if not already present
+          if uri =~ /^mongodb:\/\/([^@]+@)/
+            # credentials already in URI — leave as-is
+          else
+            host_part = uri.sub(/^mongodb:\/\//, "")
+            creds = [username, password ? ":#{password}" : nil].compact.join
+            uri = "mongodb://#{creds}@#{host_part}"
+          end
+        end
+        uri
+      end
+
+      def extract_db_name(connection_string)
+        # mongodb://host:port/dbname  ->  dbname
+        # Strip query string first
+        path = connection_string.to_s.split("?").first
+        db = path.split("/").last
+        db && !db.empty? ? db : "tina4"
+      end
+
+      # ── SQL-to-MongoDB translator ──────────────────────────────────────
+
+      def parse_sql(sql, params = [])
+        sql_stripped = sql.strip
+        upper = sql_stripped.upcase
+
+        # Bind positional ? params
+        bound_sql = bind_params(sql_stripped, params)
+
+        if upper.start_with?("SELECT")
+          parse_select(bound_sql)
+        elsif upper.start_with?("INSERT INTO")
+          parse_insert(bound_sql)
+        elsif upper.start_with?("UPDATE")
+          parse_update(bound_sql)
+        elsif upper.start_with?("DELETE FROM")
+          parse_delete(bound_sql)
+        elsif upper.start_with?("CREATE TABLE") || upper.start_with?("CREATE COLLECTION")
+          parse_create(bound_sql)
+        else
+          { operation: :unknown, collection: nil }
+        end
+      end
+
+      def bind_params(sql, params)
+        return sql if params.nil? || params.empty?
+
+        idx = -1
+        sql.gsub("?") do
+          idx += 1
+          v = params[idx]
+          v.is_a?(String) ? "'#{v.gsub("'", "\\\\'")}'" : v.to_s
+        end
+      end
+
+      # ── SELECT parsing ─────────────────────────────────────────────────
+
+      def parse_select(sql)
+        result = { operation: :find }
+
+        # Extract table name (FROM clause)
+        if (m = sql.match(/\bFROM\s+(\w+)/i))
+          result[:collection] = m[1].to_sym
+        else
+          result[:collection] = :unknown
+          return result
+        end
+
+        # Projection (columns)
+        result[:projection] = parse_projection(sql)
+
+        # WHERE clause
+        where_clause = extract_clause(sql, "WHERE", %w[ORDER GROUP LIMIT OFFSET HAVING])
+        result[:filter] = where_clause ? parse_where(where_clause) : {}
+
+        # ORDER BY
+        result[:sort] = parse_order_by(sql)
+
+        # LIMIT / OFFSET
+        result[:limit] = extract_limit(sql)
+        result[:skip]  = extract_offset(sql)
+
+        result
+      end
+
+      def parse_projection(sql)
+        m = sql.match(/^SELECT\s+(.*?)\s+FROM\b/im)
+        return {} unless m
+
+        cols = m[1].strip
+        return {} if cols == "*"
+
+        proj = {}
+        cols.split(",").each do |col|
+          col = col.strip
+          # Handle AS aliases — use the alias as field name
+          field = col.split(/\s+AS\s+/i).first.strip
+          proj[field] = 1
+        end
+        proj
+      end
+
+      def parse_order_by(sql)
+        m = sql.match(/\bORDER\s+BY\s+(.*?)(?:\s+LIMIT|\s+OFFSET|\s*$)/im)
+        return {} unless m
+
+        sort = {}
+        m[1].split(",").each do |part|
+          part = part.strip
+          if (pm = part.match(/^(\w+)\s+(ASC|DESC)$/i))
+            sort[pm[1]] = pm[2].upcase == "DESC" ? -1 : 1
+          else
+            sort[part] = 1
+          end
+        end
+        sort
+      end
+
+      def extract_limit(sql)
+        m = sql.match(/\bLIMIT\s+(\d+)/i)
+        m ? m[1].to_i : nil
+      end
+
+      def extract_offset(sql)
+        m = sql.match(/\bOFFSET\s+(\d+)/i)
+        m ? m[1].to_i : nil
+      end
+
+      # ── WHERE clause parser → Mongo filter hash ───────────────────────
+
+      def parse_where(clause)
+        clause = clause.strip
+        return {} if clause.empty?
+
+        # Handle OR at top level
+        or_parts = split_top_level(clause, /\bOR\b/i)
+        if or_parts.length > 1
+          return { "$or" => or_parts.map { |p| parse_where(p) } }
+        end
+
+        # Handle AND at top level
+        and_parts = split_top_level(clause, /\bAND\b/i)
+        if and_parts.length > 1
+          conditions = and_parts.map { |p| parse_where(p) }
+          merged = {}
+          conditions.each { |c| merged.merge!(c) }
+          return merged
+        end
+
+        parse_condition(clause)
+      end
+
+      # Split a string on a regex delimiter only at top level (not inside parens)
+      def split_top_level(str, delimiter_re)
+        parts = []
+        depth = 0
+        current = ""
+        tokens = str.split(/(\(|\)|\s+)/m)
+
+        # Rebuild token stream and split on delimiter
+        rebuilt = str
+        # Simple approach: scan character by character
+        parts = []
+        current = ""
+        i = 0
+        while i < str.length
+          ch = str[i]
+          if ch == "("
+            depth += 1
+            current += ch
+          elsif ch == ")"
+            depth -= 1
+            current += ch
+          elsif depth == 0
+            # Check for delimiter match at this position
+            remaining = str[i..]
+            m = remaining.match(/\A\s*#{delimiter_re.source}\s*/i)
+            if m
+              parts << current.strip
+              current = ""
+              i += m[0].length
+              next
+            else
+              current += ch
+            end
+          else
+            current += ch
+          end
+          i += 1
+        end
+        parts << current.strip unless current.strip.empty?
+        parts.length > 1 ? parts : [str]
+      end
+
+      def parse_condition(clause)
+        clause = clause.strip.gsub(/^\(+/, "").gsub(/\)+$/, "").strip
+
+        # IS NULL / IS NOT NULL
+        if (m = clause.match(/^(\w+)\s+IS\s+NOT\s+NULL$/i))
+          return { m[1] => { "$ne" => nil } }
+        end
+        if (m = clause.match(/^(\w+)\s+IS\s+NULL$/i))
+          return { m[1] => nil }
+        end
+
+        # IN (...)
+        if (m = clause.match(/^(\w+)\s+IN\s*\((.+)\)$/i))
+          values = m[2].split(",").map { |v| parse_value(v.strip) }
+          return { m[1] => { "$in" => values } }
+        end
+
+        # NOT IN (...)
+        if (m = clause.match(/^(\w+)\s+NOT\s+IN\s*\((.+)\)$/i))
+          values = m[2].split(",").map { |v| parse_value(v.strip) }
+          return { m[1] => { "$nin" => values } }
+        end
+
+        # LIKE → $regex
+        if (m = clause.match(/^(\w+)\s+LIKE\s+'(.+)'$/i))
+          pattern = m[2].gsub("%", ".*").gsub("_", ".")
+          return { m[1] => { "$regex" => pattern, "$options" => "i" } }
+        end
+
+        # NOT LIKE → $not $regex
+        if (m = clause.match(/^(\w+)\s+NOT\s+LIKE\s+'(.+)'$/i))
+          pattern = m[2].gsub("%", ".*").gsub("_", ".")
+          return { m[1] => { "$not" => /#{pattern}/i } }
+        end
+
+        # Comparison operators: !=, <>, >=, <=, >, <, =
+        ops = [["!=", "$ne"], ["<>", "$ne"], [">=", "$gte"], ["<=", "$lte"],
+               [">", "$gt"], ["<", "$lt"], ["=", "$eq"]]
+        ops.each do |op, mongo_op|
+          if (m = clause.match(/^(\w+)\s*#{Regexp.escape(op)}\s*(.+)$/i))
+            field = m[1]
+            value = parse_value(m[2].strip)
+            if mongo_op == "$eq"
+              return { field => value }
+            else
+              return { field => { mongo_op => value } }
+            end
+          end
+        end
+
+        # Fallback — return as a raw string comment (best-effort)
+        {}
+      end
+
+      def parse_value(str)
+        str = str.strip
+        if str.start_with?("'") && str.end_with?("'")
+          str[1..-2]
+        elsif str =~ /\A-?\d+\z/
+          str.to_i
+        elsif str =~ /\A-?\d+\.\d+\z/
+          str.to_f
+        elsif str.upcase == "TRUE"
+          true
+        elsif str.upcase == "FALSE"
+          false
+        elsif str.upcase == "NULL"
+          nil
+        else
+          str
+        end
+      end
+
+      # ── INSERT parsing ─────────────────────────────────────────────────
+
+      def parse_insert(sql)
+        result = { operation: :insert }
+
+        m = sql.match(/INSERT\s+INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/im)
+        unless m
+          result[:collection] = :unknown
+          result[:document] = {}
+          return result
+        end
+
+        result[:collection] = m[1].to_sym
+        cols = m[2].split(",").map(&:strip)
+        vals = parse_value_list(m[3])
+
+        result[:document] = cols.each_with_object({}).with_index do |(col, doc), i|
+          doc[col] = vals[i]
+        end
+
+        result
+      end
+
+      def parse_value_list(str)
+        # Split on commas not inside quotes
+        vals = []
+        current = ""
+        in_quote = false
+        str.each_char do |ch|
+          if ch == "'" && !in_quote
+            in_quote = true
+            current += ch
+          elsif ch == "'" && in_quote
+            in_quote = false
+            current += ch
+          elsif ch == "," && !in_quote
+            vals << parse_value(current.strip)
+            current = ""
+          else
+            current += ch
+          end
+        end
+        vals << parse_value(current.strip) unless current.strip.empty?
+        vals
+      end
+
+      # ── UPDATE parsing ─────────────────────────────────────────────────
+
+      def parse_update(sql)
+        result = { operation: :update }
+
+        m = sql.match(/UPDATE\s+(\w+)\s+SET\s+(.+?)(?:\s+WHERE\s+(.+))?$/im)
+        unless m
+          result[:collection] = :unknown
+          result[:updates] = {}
+          result[:filter] = {}
+          return result
+        end
+
+        result[:collection] = m[1].to_sym
+
+        # Parse SET assignments
+        updates = {}
+        set_clause = m[2].strip
+        # Split on comma, skip commas inside quotes
+        assignments = split_assignments(set_clause)
+        assignments.each do |assign|
+          parts = assign.split("=", 2)
+          next unless parts.length == 2
+
+          key = parts[0].strip
+          val = parse_value(parts[1].strip)
+          updates[key] = val
+        end
+        result[:updates] = updates
+
+        # Parse WHERE
+        where_str = m[3]&.strip
+        result[:filter] = where_str && !where_str.empty? ? parse_where(where_str) : {}
+
+        result
+      end
+
+      def split_assignments(set_clause)
+        parts = []
+        current = ""
+        in_quote = false
+        set_clause.each_char do |ch|
+          if ch == "'" && !in_quote
+            in_quote = true
+            current += ch
+          elsif ch == "'" && in_quote
+            in_quote = false
+            current += ch
+          elsif ch == "," && !in_quote
+            parts << current.strip
+            current = ""
+          else
+            current += ch
+          end
+        end
+        parts << current.strip unless current.strip.empty?
+        parts
+      end
+
+      # ── DELETE parsing ─────────────────────────────────────────────────
+
+      def parse_delete(sql)
+        result = { operation: :delete }
+
+        m = sql.match(/DELETE\s+FROM\s+(\w+)(?:\s+WHERE\s+(.+))?$/im)
+        unless m
+          result[:collection] = :unknown
+          result[:filter] = {}
+          return result
+        end
+
+        result[:collection] = m[1].to_sym
+        where_str = m[2]&.strip
+        result[:filter] = where_str && !where_str.empty? ? parse_where(where_str) : {}
+
+        result
+      end
+
+      # ── CREATE TABLE parsing ───────────────────────────────────────────
+
+      def parse_create(sql)
+        m = sql.match(/CREATE\s+(?:TABLE|COLLECTION)\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)/im)
+        {
+          operation: :create_collection,
+          collection: m ? m[1].to_sym : :unknown
+        }
+      end
+
+      # ── Extract a named clause from SQL ───────────────────────────────
+
+      def extract_clause(sql, clause_keyword, stop_keywords = [])
+        pattern_parts = stop_keywords.map { |kw| "\\b#{kw}\\b" }.join("|")
+        stop_pattern = pattern_parts.empty? ? "$" : "(?:#{pattern_parts}|$)"
+        m = sql.match(/\b#{clause_keyword}\s+(.*?)(?=\s*#{stop_pattern})/im)
+        m ? m[1].strip : nil
+      end
+
+      # ── Document conversion ────────────────────────────────────────────
+
+      def mongo_doc_to_hash(doc)
+        doc.each_with_object({}) do |(k, v), h|
+          key = k.to_s == "_id" ? :_id : k.to_s.to_sym
+          h[key] = v.is_a?(BSON::ObjectId) ? v.to_s : v
+        end
+      end
+    end
+  end
+end

data/lib/tina4/drivers/odbc_driver.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+module Tina4
+  module Drivers
+    class OdbcDriver
+      attr_reader :connection
+
+      # Connect to an ODBC data source.
+      #
+      # Connection string formats:
+      #   odbc:///DSN=MyDSN
+      #   odbc:///DSN=MyDSN;UID=user;PWD=pass
+      #   odbc:///DRIVER={SQL Server};SERVER=host;DATABASE=db
+      #
+      # The leading scheme prefix "odbc:///" is stripped; the remainder is
+      # passed verbatim to ODBC::Database.new as a connection string.
+      # username: and password: are appended as UID/PWD if not already present
+      # in the connection string.
+      def connect(connection_string, username: nil, password: nil)
+        begin
+          require "odbc"
+        rescue LoadError
+          raise LoadError,
+            "The 'ruby-odbc' gem is required for ODBC connections. " \
+            "Install: gem install ruby-odbc"
+        end
+
+        dsn_string = connection_string.to_s
+          .sub(/^odbc:\/\/\//, "")
+          .sub(/^odbc:\/\//, "")
+          .sub(/^odbc:/, "")
+
+        # Append credentials if provided and not already embedded
+        if username && !dsn_string.match?(/\bUID=/i)
+          dsn_string = "#{dsn_string};UID=#{username}"
+        end
+        if password && !dsn_string.match?(/\bPWD=/i)
+          dsn_string = "#{dsn_string};PWD=#{password}"
+        end
+
+        @connection = ODBC::Database.new(dsn_string)
+        @in_transaction = false
+        self
+      end
+
+      def close
+        @connection&.disconnect
+        @connection = nil
+      end
+
+      def connected?
+        !@connection.nil?
+      end
+
+      # Execute a SELECT query and return rows as an array of symbol-keyed hashes.
+      def execute_query(sql, params = [])
+        stmt = if params && !params.empty?
+          s = @connection.prepare(sql)
+          s.execute(*params)
+          s
+        else
+          @connection.run(sql)
+        end
+
+        columns = stmt.columns(true).map { |c| c.name.to_s.to_sym }
+        rows = []
+        while (row = stmt.fetch)
+          rows << columns.zip(row).to_h
+        end
+        stmt.drop
+        rows
+      rescue => e
+        stmt&.drop rescue nil
+        raise e
+      end
+
+      # Execute DDL or DML without returning rows.
+      def execute(sql, params = [])
+        if params && !params.empty?
+          stmt = @connection.prepare(sql)
+          stmt.execute(*params)
+          stmt.drop
+        else
+          @connection.do(sql)
+        end
+        nil
+      end
+
+      # ODBC does not expose a universal last-insert-id API.
+      # Drivers that support it can be queried via execute_query after insert.
+      def last_insert_id
+        nil
+      end
+
+      def placeholder
+        "?"
+      end
+
+      def placeholders(count)
+        (["?"] * count).join(", ")
+      end
+
+      # Build paginated SQL.
+      # Tries OFFSET/FETCH NEXT (SQL Server, newer ODBC sources) first.
+      # Falls back to LIMIT/OFFSET for sources that support it (MySQL, PostgreSQL via ODBC).
+      # The caller (Database#fetch) already gates on whether LIMIT is already present.
+      def apply_limit(sql, limit, offset = 0)
+        offset ||= 0
+        if offset > 0
+          # SQL Server / ANSI syntax — requires ORDER BY; add a no-op if absent
+          if sql.upcase.include?("ORDER BY")
+            "#{sql} OFFSET #{offset} ROWS FETCH NEXT #{limit} ROWS ONLY"
+          else
+            # LIMIT/OFFSET fallback (MySQL, PostgreSQL via ODBC, SQLite via ODBC)
+            "#{sql} LIMIT #{limit} OFFSET #{offset}"
+          end
+        else
+          "#{sql} LIMIT #{limit}"
+        end
+      end
+
+      def begin_transaction
+        return if @in_transaction
+        @connection.autocommit = false
+        @in_transaction = true
+      end
+
+      def commit
+        return unless @in_transaction
+        @connection.commit
+        @connection.autocommit = true
+        @in_transaction = false
+      end
+
+      def rollback
+        return unless @in_transaction
+        @connection.rollback
+        @connection.autocommit = true
+        @in_transaction = false
+      end
+
+      # List all user tables via ODBC metadata.
+      def tables
+        stmt = @connection.tables
+        rows = []
+        while (row = stmt.fetch_hash)
+          type = row["TABLE_TYPE"] || row[:TABLE_TYPE] || ""
+          name = row["TABLE_NAME"] || row[:TABLE_NAME]
+          rows << name.to_s if type.to_s.upcase == "TABLE" && name
+        end
+        stmt.drop
+        rows
+      rescue => e
+        stmt&.drop rescue nil
+        raise e
+      end
+
+      # Return column metadata for a table via ODBC metadata.
+      def columns(table_name)
+        stmt = @connection.columns(table_name.to_s)
+        result = []
+        while (row = stmt.fetch_hash)
+          name    = row["COLUMN_NAME"]    || row[:COLUMN_NAME]
+          type    = row["TYPE_NAME"]      || row[:TYPE_NAME]
+          nullable_val = row["NULLABLE"]  || row[:NULLABLE]
+          default = row["COLUMN_DEF"]     || row[:COLUMN_DEF]
+          result << {
+            name: name.to_s,
+            type: type.to_s,
+            nullable: nullable_val.to_i == 1,
+            default: default,
+            primary_key: false  # ODBC metadata does not reliably expose PK flag here
+          }
+        end
+        stmt.drop
+        result
+      rescue => e
+        stmt&.drop rescue nil
+        raise e
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        hash.each_with_object({}) do |(k, v), h|
+          h[k.to_s.to_sym] = v if k.is_a?(String) || k.is_a?(Symbol)
+        end
+      end
+    end
+  end
+end

data/lib/tina4/orm.rb

@@ -649,5 +649,42 @@ module Tina4
 
       @relationship_cache[name] = klass.find(fk_value)
     end
+
+    public
+
+    # ── Imperative relationship methods (ad-hoc, like Python/PHP/Node) ──
+
+    def query_has_one(related_class, foreign_key: nil)
+      pk = self.class.primary_key_field || :id
+      pk_value = __send__(pk)
+      return nil unless pk_value
+
+      fk = foreign_key || "#{self.class.name.split('::').last.downcase}_id"
+      result = related_class.db.fetch_one(
+        "SELECT * FROM #{related_class.table_name} WHERE #{fk} = ?", [pk_value]
+      )
+      result ? related_class.from_hash(result) : nil
+    end
+
+    def query_has_many(related_class, foreign_key: nil, limit: 100, offset: 0)
+      pk = self.class.primary_key_field || :id
+      pk_value = __send__(pk)
+      return [] unless pk_value
+
+      fk = foreign_key || "#{self.class.name.split('::').last.downcase}_id"
+      results = related_class.db.fetch(
+        "SELECT * FROM #{related_class.table_name} WHERE #{fk} = ?",
+        [pk_value], limit: limit, offset: offset
+      )
+      results.map { |row| related_class.from_hash(row) }
+    end
+
+    def query_belongs_to(related_class, foreign_key: nil)
+      fk = foreign_key || "#{related_class.name.split('::').last.downcase}_id"
+      fk_value = respond_to?(fk.to_sym) ? __send__(fk.to_sym) : nil
+      return nil unless fk_value
+
+      related_class.find(fk_value)
+    end
   end
 end

data/lib/tina4/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tina4
-  VERSION = "3.10.54"
+  VERSION = "3.10.55"
 end

data/lib/tina4.rb

@@ -59,6 +59,8 @@ module Tina4
     autoload :MysqlDriver,    File.expand_path("tina4/drivers/mysql_driver", __dir__)
     autoload :MssqlDriver,    File.expand_path("tina4/drivers/mssql_driver", __dir__)
     autoload :FirebirdDriver, File.expand_path("tina4/drivers/firebird_driver", __dir__)
+    autoload :MongodbDriver,  File.expand_path("tina4/drivers/mongodb_driver", __dir__)
+    autoload :OdbcDriver,     File.expand_path("tina4/drivers/odbc_driver", __dir__)
   end
 
   # ── Lazy-loaded: session handlers ─────────────────────────────────────

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tina4ruby
 version: !ruby/object:Gem::Version
-  version: 3.10.54
+  version: 3.10.55
 platform: ruby
 authors:
 - Tina4 Team
@@ -294,8 +294,10 @@ files:
 - lib/tina4/dev_mailbox.rb
 - lib/tina4/dev_reload.rb
 - lib/tina4/drivers/firebird_driver.rb
+- lib/tina4/drivers/mongodb_driver.rb
 - lib/tina4/drivers/mssql_driver.rb
 - lib/tina4/drivers/mysql_driver.rb
+- lib/tina4/drivers/odbc_driver.rb
 - lib/tina4/drivers/postgres_driver.rb
 - lib/tina4/drivers/sqlite_driver.rb
 - lib/tina4/env.rb