gloo 4.6.1 → 5.0

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

data/lib/gloo/objs/data/sqlite.rb

@@ -1,174 +0,0 @@
-# Author::    Eric Crane  (mailto:eric.crane@mac.com)
-# Copyright:: Copyright (c) 2020 Eric Crane.  All rights reserved.
-#
-# A Sqlite3 database connection.
-#
-# https://www.rubydoc.info/gems/sqlite3/1.3.11
-# https://www.devdungeon.com/content/ruby-sqlite-tutorial
-#
-# db.results_as_hash = true
-#   Set results to return as Hash object.
-#   This is slower but offers a huge convenience.
-#   Consider turning it off for high performance situations.
-#   Each row will have the column name as the hash key.
-#
-# # Alternatively, to only get one row and discard the rest,
-# replace `db.query()` with `db.get_first_value()`.
-#
-require 'sqlite3'
-
-module Gloo
-  module Objs
-    class Sqlite < Gloo::Core::Obj
-
-      KEYWORD = 'sqlite'.freeze
-      KEYWORD_SHORT = 'sqlite'.freeze
-
-      DB = 'database'.freeze
-      DEFAULT_DB = 'test.db'.freeze
-
-      DB_REQUIRED_ERR = 'The database name is required!'.freeze
-      DB_NOT_FOUND_ERR = 'The database file was not found!'.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 DB, DEFAULT_DB, self
-      end
-
-      # ---------------------------------------------------------------------
-      #    Messages
-      # ---------------------------------------------------------------------
-
-      #
-      # Get a list of message names that this object receives.
-      #
-      def self.messages
-        return super + [ 'verify' ]
-      end
-
-      #
-      # Verify access to the Sqlite database specified.
-      #
-      def msg_verify
-        name = db_value
-        if name.empty?
-          @engine.err DB_REQUIRED_ERR
-          @engine.heap.it.set_to false
-          return
-        end
-
-        unless File.exist? name
-          @engine.err DB_NOT_FOUND_ERR
-          @engine.heap.it.set_to false
-          return
-        end
-
-        return unless connects?
-
-        @engine.heap.it.set_to true
-      end
-
-      # ---------------------------------------------------------------------
-      #    DB functions (all database connections)
-      # ---------------------------------------------------------------------
-
-      #
-      # Open a connection and execute the SQL statement.
-      # Return the resulting data.
-      #
-      def query( sql, params = nil )
-        name = db_value
-        unless name
-          @engine.err DB_REQUIRED_ERR
-          return
-        end
-
-        db = SQLite3::Database.open name
-        # db.results_as_hash = true
-        results = db.query( sql, params )
-
-        return results
-      end
-
-      # 
-      # Based on the result set, build a QueryResult object.
-      # 
-      def get_query_result( result )
-        rows = []        
-        while ( row = result.next ) do
-          rows << row
-        end
-
-        return QueryResult.new( result.columns, rows )
-      end
-
-
-      # ---------------------------------------------------------------------
-      #    Private functions
-      # ---------------------------------------------------------------------
-
-      private
-
-      #
-      # Get the Database file from the child object.
-      # Returns nil if there is none.
-      #
-      def db_value
-        o = find_child DB
-        return nil unless o
-
-        return o.value
-      end
-
-      #
-      # Try the connection and make sure it works.
-      # Returns true if we can connect and do a query.
-      #
-      def connects?
-        begin
-          db = SQLite3::Database.open db_value
-          sql = "SELECT COUNT(name) FROM sqlite_master WHERE type='table'"
-          db.get_first_value sql
-        rescue => e
-          @engine.log_exception e
-          @engine.heap.it.set_to false
-          return false
-        end
-        return true
-      end
-
-    end
-  end
-end