gloo 4.7.0 → 5.0

data/lib/gloo/objs/data/mysql.rb

@@ -1,254 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
-#
-# A MySQL database connection.
-#
-#
-# https://github.com/brianmario/mysql2
-# https://www.rubydoc.info/gems/mysql2/0.2.3/Mysql2/Client
-#
-# Connection Parameters
-#   user     = opts[:username]
-#   pass     = opts[:password]
-#   host     = opts[:host] || 'localhost'
-#   port     = opts[:port] || 3306
-#   database = opts[:database]
-#   socket   = opts[:socket]
-#   flags    = opts[:flags] || 0
-#
-require 'mysql2'
-
-module Gloo
-  module Objs
-    class Mysql < Gloo::Core::Obj
-
-      KEYWORD = 'mysql'.freeze
-      KEYWORD_SHORT = 'mysql'.freeze
-
-      HOST = 'host'.freeze
-      DB = 'database'.freeze
-      USER = 'username'.freeze
-      PASSWD = 'password'.freeze
-
-      #
-      # The name of the object type.
-      #
-      def self.typename
-        return KEYWORD
-      end
-
-      #
-      # The short name of the object type.
-      #
-      def self.short_typename
-        return KEYWORD_SHORT
-      end
-
-      # ---------------------------------------------------------------------
-      #    Children
-      # ---------------------------------------------------------------------
-
-      #
-      # Does this object have children to add when an object
-      # is created in interactive mode?
-      # This does not apply during obj load, etc.
-      #
-      def add_children_on_create?
-        return true
-      end
-
-      #
-      # Add children to this object.
-      # This is used by containers to add children needed
-      # for default configurations.
-      #
-      def add_default_children
-        fac = @engine.factory
-        fac.create_string HOST, nil, self
-        fac.create_string DB, nil, self
-        fac.create_string USER, nil, self
-        fac.create_string PASSWD, nil, self
-      end
-
-      # ---------------------------------------------------------------------
-      #    Messages
-      # ---------------------------------------------------------------------
-
-      #
-      # Get a list of message names that this object receives.
-      #
-      def self.messages
-        return super + [ 'verify' ]
-      end
-
-      #
-      # SSH to the host and execute the command, then update result.
-      #
-      def msg_verify
-        return unless connects?
-
-        @engine.heap.it.set_to true
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    DB functions (all database connections)
-      # ---------------------------------------------------------------------
-
-      #
-      # Get the client object.
-      # It might be cached, so check first.
-      # If it is not cached, create a new one.
-      #
-      def get_client
-        app = @engine.running_app
-
-        client = app.db_client_for_obj( self ) if app 
-
-        if client && client.ping
-          @engine.log.debug "Connection is established and active."
-          return client
-        elsif client
-          @engine.log.debug "Connection is established but NOT active.  Reconnecting."
-        else
-          @engine.log.debug "Opening a new Connection."
-        end
-
-        h = {
-          host: host_value,
-          database: db_value,
-          username: user_value,
-          password: passwd_value
-        }
-        client = Mysql2::Client.new( h )
-
-        app.cache_db_client( self, client ) if app
-        
-        return client
-      end
-
-      #
-      # Open a connection and execute the SQL statement.
-      # Return the resulting data.
-      #
-      def query( sql, params = nil )
-        client = get_client
-
-        heads = []
-        data = []
-        begin
-          if params
-            pst = client.prepare( sql )
-            rs = pst.execute( *params, :as => :array )
-            if rs
-              rs.each do |row|
-                arr = []
-                row.each do |o| 
-                  arr << o
-                end
-                data << arr
-              end
-            end
-          else
-            rs = client.query( sql, :as => :array ) 
-            if rs
-              rs.each do |row|
-                data << row
-              end
-            end
-          end
-
-          heads = rs.fields if rs
-        rescue => e
-          @engine.log_exception e
-        end
-
-        return [ heads, data ]
-      end
-
-      # 
-      # Based on the result set, build a QueryResult object.
-      # 
-      def get_query_result( result )
-        return QueryResult.new result[0], result[1], @engine
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Private functions
-      # ---------------------------------------------------------------------
-
-      private
-
-      #
-      # Get the host from the child object.
-      # Returns nil if there is none.
-      #
-      def host_value
-        o = find_child HOST
-        return nil unless o
-
-        o = Gloo::Objs::Alias.resolve_alias( @engine, o )
-        return o.value
-      end
-
-      #
-      # Get the Database name from the child object.
-      # Returns nil if there is none.
-      #
-      def db_value
-        o = find_child DB
-        return nil unless o
-
-        o = Gloo::Objs::Alias.resolve_alias( @engine, o )
-        return o.value
-      end
-
-      #
-      # Get the Username from the child object.
-      # Returns nil if there is none.
-      #
-      def user_value
-        o = find_child USER
-        return nil unless o
-
-        o = Gloo::Objs::Alias.resolve_alias( @engine, o )
-        return o.value
-      end
-
-      #
-      # Get the Password name from the child object.
-      # Returns nil if there is none.
-      #
-      def passwd_value
-        o = find_child PASSWD
-        return nil unless o
-
-        o = Gloo::Objs::Alias.resolve_alias( @engine, o )
-        return o.value
-      end
-
-      #
-      # Try the connection and make sure it works.
-      # Returns true if we can establish a connection.
-      #
-      def connects?
-        begin
-          h = {
-            host: host_value,
-            database: db_value,
-            username: user_value,
-            password: passwd_value
-          }
-          Mysql2::Client.new( h )
-        rescue => e
-          @engine.log_exception e
-          @engine.heap.it.set_to false
-          return false
-        end
-        return true
-      end
-
-    end
-  end
-end

data/lib/gloo/objs/data/query.rb

@@ -1,269 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
-#
-# A SQL database query.
-# Relies on a database connection object.
-#
-
-module Gloo
-  module Objs
-    class Query < Gloo::Core::Obj
-
-      KEYWORD = 'query'.freeze
-      KEYWORD_SHORT = 'sql'.freeze
-
-      DB = 'database'.freeze
-      SQL = 'sql'.freeze
-      RESULT = 'result'.freeze
-      PARAMS = 'params'.freeze
-      SIMPLE_LIST = 'simple_list'.freeze
-
-      DB_MISSING_ERR = 'The database connection is missing!'.freeze
-
-      #
-      # The name of the object type.
-      #
-      def self.typename
-        return KEYWORD
-      end
-
-      #
-      # The short name of the object type.
-      #
-      def self.short_typename
-        return KEYWORD_SHORT
-      end
-
-      # 
-      # Get the result container if it exists.
-      # 
-      def get_result_can
-        result_can = find_child RESULT
-        result_can = Gloo::Objs::Alias.resolve_alias( @engine, result_can )
-        return result_can
-      end
-
-      # ---------------------------------------------------------------------
-      #    Children
-      # ---------------------------------------------------------------------
-
-      #
-      # Does this object have children to add when an object
-      # is created in interactive mode?
-      # This does not apply during obj load, etc.
-      #
-      def add_children_on_create?
-        return true
-      end
-
-      #
-      # Add children to this object.
-      # This is used by containers to add children needed
-      # for default configurations.
-      #
-      def add_default_children
-        fac = @engine.factory
-        fac.create_alias DB, nil, self
-        fac.create_string SQL, nil, self
-        fac.create_can RESULT, self
-      end
-
-      # ---------------------------------------------------------------------
-      #    Messages
-      # ---------------------------------------------------------------------
-
-      #
-      # Get a list of message names that this object receives.
-      #
-      def self.messages
-        return super + [ 'run' ]
-      end
-
-      #
-      # Run the query and process the results.
-      #
-      def msg_run
-        db = db_obj
-        return unless db
-
-        begin
-          clear_results
-
-          log_query sql_value, param_array
-          result = db.query( sql_value, param_array )
-          process_result( result, db )
-        rescue => e
-          @engine.log_exception e
-          return
-        end
-      end
-
-      #
-      # Run the query and return the results.
-      #
-      def run_query
-        db = db_obj
-        return unless db
-
-        begin
-          log_query sql_value, param_array
-
-          db_start = ::Time.now
-          result = db.query( sql_value, param_array )
-          db_done = ::Time.now
-          elapsed = ( ( db_done - db_start ) * 1000.0 ).round(2)
-  
-          app = @engine.running_app
-          app.add_db_time elapsed if app
-          return result
-        rescue => e
-          @engine.log_exception e
-          return
-        end
-      end
-
-      # 
-      # Write the query to the log.
-      # 
-      def log_query sql, params
-        @engine.log.info "SQL PARAMS: #{params}" if params
-        @engine.log.info "SQL: #{sql}"
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Output as simple list
-      # ---------------------------------------------------------------------
-
-      # 
-      # Should the output be put in a simple list?
-      # 
-      def simple_list?
-        o = find_child SIMPLE_LIST
-        return false unless o
-
-        return o.value
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Private functions
-      # ---------------------------------------------------------------------
-
-      private
-
-      #
-      # Get the database connection.
-      #
-      def db_obj
-        o = find_child DB
-
-        unless o
-          @engine.err DB_MISSING_ERR
-          return nil
-        end
-
-        return Gloo::Objs::Alias.resolve_alias( @engine, o )
-      end
-
-      #
-      # Get the SQL from the child object.
-      # Returns nil if there is none.
-      #
-      def sql_value
-        o = find_child SQL
-        return nil unless o
-
-        o = Gloo::Objs::Alias.resolve_alias( @engine, o )
-        return o.value
-      end
-
-      #
-      # Do something with the result of the SQL Query call.
-      # If there's a result container, we'll create objects in it.
-      # If not, we'll just show the output in the console.
-      #
-      def process_result( result, db )
-        return if result.nil?
-
-        query_result = db.get_query_result( result )
-        return unless query_result
-        return unless query_result.has_data_to_show?
-
-        result_can = get_result_can
-
-        if result_can
-          if simple_list?
-            query_result.update_result_container_simple result_can
-          else
-            query_result.update_result_container result_can
-          end
-        else
-          query_result.show
-        end
-      end
-
-      #
-      # Get the array of parameters.
-      # If there is no PARAM container of if it is empty,
-      # we'll return a nil value.
-      #
-      def param_array
-        o = find_child PARAMS
-        return nil unless o
-
-        return nil if o.child_count.zero?
-
-        params = []
-        o.children.each do |p|
-          p = Gloo::Objs::Alias.resolve_alias( @engine, p )
-          params << p.sql_value
-        end
-
-        return params
-      end
-
-      # 
-      # Clear out results container.
-      # Prevents data from the last use being used in this 
-      # one if no data was found.
-      # 
-      def clear_results
-        result_can = get_result_can
-        return unless result_can
-        return unless result_can.child_count.positive?
-
-        if result_is_values?
-          clear_values
-        else
-          get_result_can.delete_children
-        end
-      end
-
-      # 
-      # Is the result container a list of values?
-      # If not it is a list of rows.
-      # 
-      def result_is_values?
-        first_child = get_result_can.children.first
-
-        if first_child && first_child&.is_container?
-          return false
-        end
-
-        return true
-      end
-
-      # 
-      # Clear out the values in the results container.
-      # 
-      def clear_values
-        get_result_can.children.each do |c|
-          c = Gloo::Objs::Alias.resolve_alias( @engine, c )
-          c.value = nil
-        end
-      end
-
-    end
-  end
-end

data/lib/gloo/objs/data/query_result.rb

@@ -1,158 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2022 Eric Crane.  All rights reserved.
-#
-# The result of a SQL database query.
-#
-
-module Gloo
-  module Objs
-    class QueryResult
-
-      DB = 'database'.freeze
-      SQL = 'sql'.freeze
-      RESULT = 'result'.freeze
-      PARAMS = 'params'.freeze
-
-
-      # ---------------------------------------------------------------------
-      #    Set up the Result
-      # ---------------------------------------------------------------------
-
-      # 
-      # Create the Result object
-      def initialize( heads, data, engine=nil )
-        @heads = heads
-        @data = data
-        @engine = engine
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Helper Functions
-      # ---------------------------------------------------------------------
-
-      # 
-      # Does the data contain a single row?
-      # OR, if the result is empty, return false.
-      # 
-      def single_row_result?
-        if @result_can && ( @result_can.child_count == 0 )
-          return false
-        end
-
-        return @data.count == 1
-      end
-
-      # 
-      # Does this query result have data to show?
-      # 
-      def has_data_to_show?
-        return false unless @heads
-        return false unless @data
-        return false if @heads.count == 0
-        return false if @data.count == 0
-
-        return true
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Show Results
-      # ---------------------------------------------------------------------
-
-      # 
-      # Show the result of the query
-      # 
-      def show
-        single_row_result? ? show_single_row : show_rows
-      end
-
-      # 
-      # Show a single row in a vertical, form style view.
-      # 
-      def show_single_row
-        arr = []
-        row = @data[0]
-        @heads.each_with_index do |h, i|
-          arr << [ h, row[i] ]
-        end
-        @engine.platform.table.show [ 'Field', 'Value' ], arr
-      end
-
-      # 
-      # Show multiple rows in a table view.
-      # 
-      def show_rows
-        @engine.platform.table.show @heads, @data
-      end
-
-      # ---------------------------------------------------------------------
-      #    Update results in object(s)
-      # ---------------------------------------------------------------------
-
-      #
-      # Update the result container with the data from the query.
-      #
-      def update_result_container( in_can )
-        @result_can = in_can
-        single_row_result? ? update_single_row : update_rows
-      end
-
-      #
-      # Update the result container with the data from the query.
-      #
-      def update_result_container_simple( in_can )
-        @result_can = in_can
-        single_row_result? ? update_single_row : update_rows_simple
-      end
-
-      # 
-      # The result has a single row.
-      # Map values from the result set to objects that are present.
-      # 
-      def update_single_row
-        row = @data[0]
-        @heads.each_with_index do |h, i|
-          child = @result_can.find_child h
-          child = Gloo::Objs::Alias.resolve_alias( @engine, child )
-          child.set_value row[i] if child
-        end
-      end
-
-      # 
-      # Put all rows in the result object.
-      # 
-      def update_rows
-        @data.each_with_index do |row, i|
-          can = @result_can.find_add_child( i.to_s, 'can' )
-          row.each_with_index do |v, i|
-            o = can.find_add_child( @heads[i], 'untyped' )
-            o.set_value v
-          end
-        end
-      end
-
-      # 
-      # Put all rows in the result object.
-      # 
-      def update_rows_simple
-        @data.each do |row|
-          row.each do |val|
-            o = @result_can.find_add_child( val, 'untyped' )
-            o.set_value val
-          end
-        end
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Private functions
-      # ---------------------------------------------------------------------
-
-      private
-
-
-
-    end
-  end
-end