jungle_path 0.0.0

data/lib/jungle_path/query/entity.rb

@@ -0,0 +1,141 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class Entity
+      attr_accessor :name, :alias_, :node, :parent, :symbol, :fields, :filter, :sort, :limit, :offset, :field_node, :join_field_override
+      attr_reader :left_join
+      def initialize(token, alias_, node, parent, symbol)
+        @name = Entity.get_name_from_token(token)
+        if token[-1] == "@"
+          @left_join = true
+        else
+          @left_join = false
+        end
+        if token.include? '.'
+          @join_field_override = token.split('.')[1]
+          if @join_field_override[-1] == '@'
+            @join_field_override = @join_field_override[0..-2]
+          end
+        else
+          @join_field_override = nil
+        end
+
+        @alias_ = alias_
+        @node = node
+        @parent = parent
+        @symbol = symbol
+        @fields = nil
+        @filter = nil
+        @sort = nil
+        @limit = nil
+        @offset = nil
+        @field_node = nil #If this entity object is created from within the field list put the field's node here.
+      end
+
+      def is_entity?
+        true
+      end
+
+      def find_field(name)
+        if fields
+          fields.each do |field|
+            if field.name == name
+              return field
+            end
+          end
+        end
+        nil
+      end
+
+      def find_entity(name)
+        field = find_field(name)
+        if field
+          return field
+        end
+
+        if fields
+          fields.each do |f|
+            if f.is_entity?
+              field = f.find_entity(name)
+              if field
+                return f
+                #return field
+              end
+            end
+          end
+        end
+        field
+      end
+
+      def find_symbol
+        symbol = node.symbol
+        p = parent
+        while true do
+          if p.fields.count == p.fields_that_are_entities_count and p.parent
+            symbol = p.node.symbol
+            p = p.parent
+          else
+            break
+          end
+        end
+        symbol
+      end
+
+      def find_parent_alias
+        #binding.pry
+        alias_ = nil
+        p = parent
+        while p and p.fields.count == p.fields_that_are_entities_count do
+          p = p.parent
+        end
+        alias_ = p.alias_ if p
+        alias_ = alias_.to_sym if alias_
+        alias_
+      end
+
+      def fields_that_are_entities_count
+        count = 0
+        fields.each do |field|
+          if field.is_entity?
+            count += 1
+          end
+        end
+        count
+      end
+
+      def self.get_name_from_token(token)
+        if token[-1] == "@"
+          token = token[0..-2]
+        end
+        if token.include? '.'
+          token = token.split('.')[0]
+        end
+        token = token.downcase.to_sym
+      end
+
+      def self.select_node_from_array_by_token(nodes, token)
+        # find closest matching node.
+        # see gen_node_tree.rb lines 60+...
+        node = nodes[0] # default
+        if token.include? '.'
+          name = token.split('.')[1]
+          if name[-1] == '@'
+            name = name[0..-2]
+          end
+          nodes.each do |n|
+            if n.child_table_join_column_name.to_s.start_with?(name)
+              node = n #found match
+              break
+            end
+          end
+        end
+        node #return node.
+      end
+    end
+  end
+end

data/lib/jungle_path/query/field.rb

@@ -0,0 +1,28 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class Field
+      attr_accessor :name, :node, :parent
+      def initialize(name, node, parent, is_secure = false)
+        @name = name.downcase.to_sym
+        @node = node
+        @parent = parent
+        @is_secure = is_secure
+      end
+      def is_entity?
+        false
+      end
+      def is_primary_key_column?
+        false
+      end
+      def is_secure?
+        @is_secure
+      end
+    end
+  end
+end

data/lib/jungle_path/query/field_primary_key.rb

@@ -0,0 +1,27 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class FieldPrimaryKey
+      attr_accessor :name, :node, :parent
+      def initialize(name, node, parent)
+        @name = name.downcase.to_sym
+        @node = node
+        @parent = parent
+      end
+      def is_entity?
+        false
+      end
+      def is_primary_key_column?
+        true
+      end
+      def is_secure?
+        false
+      end
+    end
+  end
+end

data/lib/jungle_path/query/filter.rb

@@ -0,0 +1,34 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class Filter
+      attr_reader :table_name, :pk_filter_query, :not_in
+      def initialize table_name, pk_filter_query, not_in=false
+        @table_name = table_name.to_sym
+        @pk_filter_query = pk_filter_query
+        @not_in = not_in
+      end
+
+      def fk_in_query table_alias, fk_column_name
+        if @not_in
+          "#{table_alias}.#{fk_column_name} not in (#{@pk_filter_query})"
+        else
+          "#{table_alias}.#{fk_column_name} in (#{@pk_filter_query})"
+        end
+      end
+
+      def to_hash
+        {table_name: @table_name, pk_filter_query: @pk_filter_query, not_in: @not_in}
+      end
+
+      def to_h
+        to_hash
+      end
+    end
+  end
+end

data/lib/jungle_path/query/float_value.rb

@@ -0,0 +1,16 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class FloatValue
+      #attr_accessor :value
+      def self.parse(value)
+        value.to_f
+      end
+    end
+  end
+end

data/lib/jungle_path/query/from.rb

@@ -0,0 +1,33 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class From
+      attr_reader :join_text, :table_name, :table_alias, :on_a_column_name, :on_b_alias, :on_b_column_name
+      def initialize join_text, table_name, table_alias, on_a_column_name=nil, on_b_alias=nil, on_b_column_name=nil
+        @join_text = join_text
+        @table_name = table_name.to_sym
+        @table_alias = table_alias
+        @on_a_column_name = on_a_column_name
+        @on_b_alias = on_b_alias
+        @on_b_column_name = on_b_column_name
+      end
+
+      def to_s
+        if join_text == "" or join_text == nil
+          "\"#{@table_name}\" #{@table_alias}"
+        else
+          "  #{@join_text} \"#{@table_name}\" #{@table_alias} on #{@table_alias}.#{@on_a_column_name} = #{@on_b_alias}.#{@on_b_column_name}"
+        end
+      end
+
+      def to_str
+        to_s
+      end
+    end
+  end
+end

data/lib/jungle_path/query/int_value.rb

@@ -0,0 +1,16 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class IntValue
+      #attr_accessor :value
+      def self.parse(value)
+        value.to_i
+      end
+    end
+  end
+end

data/lib/jungle_path/query/limit.rb

@@ -0,0 +1,19 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+
+module JunglePath
+  module Query
+    class Limit
+      #attr_accessor :value
+      def self.parse (token)
+        value = token[1..-2].strip
+        if value =~ /^[0-9]*$/
+          return value.to_i
+        end
+        raise "Found invalid limit or offset: #{token}. Limits and offsets must be integers. Such as [10]."
+      end
+    end
+  end
+end

data/lib/jungle_path/query/nested_hash_sorter.rb

@@ -0,0 +1,94 @@
+module JunglePath
+	module Query
+		class NestedHashSorter
+			def initialize(paths, sort_orders)
+				@paths = paths
+				@sort_orders = sort_orders
+			end
+
+			def sort(a, b)
+				#value = get_array_left(a, b) <=> get_array_right(a, b)
+				#can't do the above if some of the array values can be nil. Instead look at each array item individually and handle any nils:
+				#puts 'in sort'
+				value = sort_handle_nils(get_array_left(a, b), get_array_right(a, b))
+				value
+			end
+
+			def sort_handle_nils(array_a, array_b)
+				#puts 'in sort_handle_nils'
+				#puts "array_a: #{array_a}."
+				#puts "array_b: #{array_b}."
+				i = 0
+				value = 0
+				while i < array_a.length and value == 0
+					v = 0
+					a = array_a[i]
+					b = array_b[i]
+					#puts "a: #{a}."
+					#puts "b: #{b}."
+					a = 1 if a.class == TrueClass
+					a = 0 if a.class == FalseClass
+					b = 1 if b.class == TrueClass
+					b = 0 if b.class == FalseClass
+					if a == nil and b == nil
+						v = 0
+					elsif a == nil
+						v = -1
+					elsif b == nil
+						v = 1
+					else
+						v = a <=> b
+					end
+					value = v
+					i = i + 1
+				end
+				value
+			end
+
+			def get_array_left(a, b)
+				values = []
+				@paths.each_index do |i|
+					keys = @paths[i]
+					sort_order = @sort_orders[i]
+					if sort_order == :asc
+						values << get_value(a, keys)
+					else
+						values << get_value(b, keys)
+					end
+				end
+				#puts "left values: #{values}."
+				values
+			end
+
+			def get_array_right(a, b)
+				values = []
+				@paths.each_index do |i|
+					keys = @paths[i]
+					sort_order = @sort_orders[i]
+					if sort_order == :asc
+						values << get_value(b, keys)
+					else
+						values << get_value(a, keys)
+					end
+				end
+				#puts "right values: #{values}."
+				values
+			end
+
+			def get_value(hash, keys)
+				#extract a value from a nested hash
+				#puts "get_value:\n  hash: #{hash}\n  keys: #{keys}."
+				#puts ""
+				h = hash
+				keys.each do |key|
+					if h.class == Array
+						h = h[0][key]
+					else
+						h = h[key]
+					end
+				end
+				h
+			end
+		end
+	end
+end

data/lib/jungle_path/query/operator.rb

@@ -0,0 +1,17 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+require 'jungle_path/query/engine'
+
+module JunglePath
+  module Query
+    class Operator
+      #attr_accessor :value
+      def self.parse(value)
+        JunglePath::Query::Engine.operator_map[value]
+      end
+    end
+  end
+end

data/lib/jungle_path/query/query.rb

@@ -0,0 +1,23 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class Query
+      attr_reader :root, :sql, :values, :aliases, :symbols, :sort_ids, :primary_key_field_count, :apply_limit_offset_to_sql
+      def initialize(root, sql, values, aliases, symbols, sort_ids, primary_key_field_count, apply_limit_offset_to_sql=false)
+        @root = root
+        @sql = sql
+        @values = values
+        @aliases = aliases
+        @symbols = symbols
+        @sort_ids = sort_ids
+        @primary_key_field_count = primary_key_field_count
+        @apply_limit_offset_to_sql = apply_limit_offset_to_sql
+      end
+    end
+  end
+end

data/lib/jungle_path/query/sort_field.rb

@@ -0,0 +1,34 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+
+module JunglePath
+  module Query
+    class SortField
+      attr_accessor :string_value, :field_name, :entities, :sort # :asc or :desc
+      #def initialize(string_value, field_name, entities, sort_order=nil)
+      def initialize(string_value, field_name, entities, sort=nil)
+        @string_value = string_value
+        @field_name = field_name
+        @entities = entities
+        if sort
+          @sort = sort.to_sym
+        else
+          @sort = :asc
+        end
+        #puts "sort_field.string_value: #{@string_value}."
+        #puts "sort_field.field_name: #{@field_name}."
+        #puts "sort_field.entities: #{@entities}."
+      end
+
+      def value
+        if @sort == "asc"
+          @string_value
+        else
+          "#{@string_value} #{@sort}"
+        end
+      end
+    end
+  end
+end

data/lib/jungle_path/query/sql_string.rb

@@ -0,0 +1,145 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class SQLString
+      def self.generate(engine, entity, select=nil, from=nil, where=nil, sort=nil, sort_ids=nil, aliases=nil, symbols=nil, primary_key_field_count=nil)
+        primary_key_field_count = [] unless primary_key_field_count
+        aliases = {} unless aliases
+        symbols = [] unless symbols
+        outer = true unless select
+        select = [] unless select
+        from = [] unless from
+        where = [] unless where
+        sort = [] unless sort
+        sort_ids = [] unless sort_ids # need to sort sql query in id order for each table with fields in select list. This is so objects with same ID can be combinded.
+        sort_original = [] unless sort_original
+
+        generate_from(from, entity, aliases, engine.tables, symbols)
+        generate_fields(engine, entity, select, from, where, sort, sort_ids, aliases, symbols, primary_key_field_count)
+        generate_filter(entity, where)
+        generate_sort(entity, sort)
+
+        indent = "\n  "
+
+        if outer
+          hook_in_filters engine, select, from, where, sort, entity
+          sql = generate_sql(select, from, where, sort, entity, engine.apply_limit_offset_to_sql)
+          return sql, aliases, symbols, sort_ids, primary_key_field_count
+        else
+          return select, from
+        end
+      end
+
+      def self.generate_from(from, entity, aliases, tables, symbols)
+        if from.length == 0
+          from << From.new(nil, entity.node.name, entity.alias_)
+          aliases[entity.alias_.to_sym] = AliasInfo.new(entity.name, entity.alias_.to_sym, nil, tables[entity.node.name.to_sym].primary_key_columns.count)
+        else
+          if entity.left_join
+            join_text = "left join"
+          else
+            join_text = "join"
+          end
+          from << From.new(join_text, entity.node.child_table_name, entity.alias_, entity.node.child_table_join_column_name, entity.parent.alias_, entity.node.parent_table_join_column_name)
+          aliases[entity.alias_.to_sym] = AliasInfo.new(entity.name, entity.alias_.to_sym, entity.find_parent_alias, tables[entity.node.child_table_name.to_sym].primary_key_columns.count)
+            #puts "aliases: #{aliases}."
+          if entity.fields.count > entity.fields_that_are_entities_count
+            symbols << entity.find_symbol
+          end
+        end
+      end
+
+      def self.generate_fields(engine, entity, select, from, where, sort, sort_ids, aliases, symbols, primary_key_field_count)
+        if entity.fields and entity.fields.length > 0
+          entity.fields.each do |field|
+            if field.is_entity?
+              select, from = generate(engine, field, select, from, where, sort, sort_ids, aliases, symbols, primary_key_field_count)
+            else
+              if field.is_primary_key_column?
+                sort_ids << "#{entity.alias_}.#{field.name}".to_sym
+              end
+              puts "#{entity.alias_}.#{field.name} as \"#{entity.alias_}.#{field.name}\" is_secure? #{field.is_secure?}."
+              if !field.is_secure? or (field.is_secure? and engine.user.auth.is_root? or engine.user.auth.is_user_admin?)
+                select << "#{entity.alias_}.#{field.name} as \"#{entity.alias_}.#{field.name}\""
+              end
+            end
+          end
+          #puts "entity.name: #{entity.name}."
+        #else
+        #  select = "*"
+        end
+      end
+
+      def self.generate_filter(entity, where)
+        if entity.filter and entity.filter.length > 0
+          where << "and" if where.length > 0
+          entity.filter.each do |filter|
+            where << filter
+          end
+        end
+      end
+
+      def self.generate_sort(entity, sort)
+        if entity.sort and entity.sort.length > 0
+          #sort << ", " if sort.length > 0
+          entity.sort.each do |s|
+            sort << s.value
+          end
+        end
+      end
+
+      def self.hook_in_filters(engine, select, from, where, sort, entity)
+        puts "hook_in_filters QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFf"
+        #binding.pry
+        if engine.user and engine.user.query_filters
+          engine.user.query_filters.each do |filter|
+            puts "hook_in_filters: filter.table_name: #{filter.table_name}."
+            from.each do |frm|
+              puts "hook_in_filters: frm.table_name: #{frm.table_name}."
+              if frm.table_name == filter.table_name
+                table = engine.tables[frm.table_name]
+                where << "and" if where.length > 0
+                where << filter.fk_in_query(frm.table_alias, table.primary_key_columns.values[0].name)
+              # don't think I need this part:
+              #else
+              #  table = engine.tables[frm.table_name]
+              #  table.foreign_key_columns.values.each do |column|
+              #    if column.foreign_key_table_name == filter.table_name
+              #      where << "and" if where.length > 0
+              #      where << filter.fk_in_query(frm.table_alias, column.name)
+              #    end
+              #  end
+              end
+            end
+          end
+        end
+      end
+
+      def self.generate_sql(select, from, where, sort, entity, apply_limit_offset_to_sql)
+        lf = "\n"
+        indent_comma = ",\n  "
+        sql = "select\n  #{select.join(indent_comma)}\nfrom #{from.join(lf)}"
+        if where and where.length > 0
+          sql = sql + "\nwhere\n  #{where.join(' ')}"
+        end
+        if sort and sort.length > 0
+          sql =  sql + "\norder by\n  #{sort.join(', ')}"
+        end
+        if apply_limit_offset_to_sql
+          if entity.limit and entity.limit > 0
+            sql = sql + "\nlimit #{entity.limit}"
+          end
+          if entity.offset and entity.offset > 0
+            sql = sql + "\noffset #{entity.offset}"
+          end
+        end
+        sql
+      end
+    end
+  end
+end

data/lib/jungle_path/query/string_value.rb

@@ -0,0 +1,16 @@
+# query.rb
+#require 'pry-byebug'
+#require 'pp'
+#use: binding.pry where you want a break point.
+require 'set'
+
+module JunglePath
+  module Query
+    class StringValue #also used for date literals
+      #attr_accessor :value
+      def self.parse(value)
+        value[1..-2] #strip out beginning and ending quotes.
+      end
+    end
+  end
+end

data/lib/jungle_path/query.rb

@@ -0,0 +1,19 @@
+module JunglePath
+	module Query
+		require 'jungle_path/query/alias_info'
+		require 'jungle_path/query/engine'
+		require 'jungle_path/query/entity'
+		require 'jungle_path/query/field_primary_key'
+		require 'jungle_path/query/field'
+		require 'jungle_path/query/filter'
+		require 'jungle_path/query/float_value'
+		require 'jungle_path/query/from'
+		require 'jungle_path/query/int_value'
+		require 'jungle_path/query/limit'
+		require 'jungle_path/query/operator'
+		require 'jungle_path/query/query'
+		require 'jungle_path/query/sort_field'
+		require 'jungle_path/query/sql_string'
+		require 'jungle_path/query/string_value'
+	end
+end