dynamic-records-meritfront 1.1.10 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 549b1d707e2419d0444845f8c15cd1564572c0ca68a72bf208a39be116feb5f3
-  data.tar.gz: 5641ddc311be64741db802cc638b73b586be91d30edcdc171fc04949b3f57542
+  metadata.gz: c1482963a5871ccc6bb8aab98747903fff5f170ae7582fc78a1ea0b2a0897191
+  data.tar.gz: 204c714455e17ced54c0796596ec9d27bc4864174216f300915e013cc9742e92
 SHA512:
-  metadata.gz: dc0a7c85bbb2ca8cdfd931c5ae9002c319809658d1437f68d3c4356758d71a5db7e277e2bcb87caa37b44608f13bc7a1c0fd38ad0e2aeb7bcc4de3a262519e28
-  data.tar.gz: ce81fa5af8b092b10be95b3134b37051a321df53434220bca3ebbb9815b260f3fcba698891282eba179f04c22090466251c0d5a3f3e1e48d6e903b75e5197ce7
+  metadata.gz: 19cfdd5db92fcf93433b8d55f35f59a05d6f9f3c3d25f717a4869bf90b25628d4e8c9c583570e8c43fe3bda9336171b2e9c98238d7f6cddc412986684d99be4b
+  data.tar.gz: 60cd1f6b76073266fa918085787133d6024d3ad10851ca63147969fba3762775d6ca52daaa60bc5278329f95cbb30e0af12ae7f3502121c74c3023c89828399b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamic-records-meritfront (1.1.10)
+    dynamic-records-meritfront (2.0.2)
       hashid-rails
 
 GEM

data/README.md

@@ -33,31 +33,6 @@ class ApplicationRecord < ActiveRecord::Base
 end
 ```
 
-### Hashed Global IDS
-
-hashed global ids look like this: "gid://meritfront/User/K9YI4K". They also have an optional tag so it can also look like "gid://meritfront/User/K9YI4K@user_image". They are based on global ids.
-
-I have been using hgids (Hashed Global IDs) for a while now and they have some unique benefits in front-end back-end communication. This is as they:
-1. hash the id which is good practice
-2. provide a way to have tags, this is good when updating different UI elements dynamically from the backend. For instance updating the @user_image without affecting the @user_name
-3. Carry the class with them, this can allow for more abstract and efficient code, and prevents id collisions between diffrent classes.
-
-#### methods from the hashid-rails gem
-
-See the hashid-rails gem for more (https://github.com/jcypret/hashid-rails). Also note that I aliased .hashid to .hid and .find_by_hashid to .hfind
-
-#### methods from this gem
-
-1. hgid(tag: nil) - get the hgid with optional tag. Aliased to ghid
-2. hgid_as_selector(str, attribute: 'id') - get a css selector for the hgid, good for updating the front-end (especially over cable-ready and morphdom operations)
-3. self.locate_hgid(hgid_string, with_associations: nil, returns_nil: false) - locates the database record from a hgid. Here are some examples of usage:
-    - ApplicationRecord.locate_hgid(hgid) - <b>DANGEROUS</b> will return any object referenced by the hgid.
-    - User.locate_hgid(hgid) - locates the User record but only if the hgid references a user class. Fires an error if not.
-    - ApplicationRecord.locate_hgid(hgid, with_associations: [:votes]) - locates the record but only if the  record's class has a :votes active record association. So for instance, you can accept only votable objects for upvote functionality. Fires an error if the hgid does not match.
-    - User.locate_hgid(hgid, returns_nil: true) - locates the hgid but only if it is the user class. Returns nil if not.
-4. get_hgid_tag(hgid) - returns the tag attached to the hgid
-5. self.blind_hgid(id, tag) - creates a hgid without bringing the object down from the database. Useful with hashid-rails encode_id and decode_id methods
-
 ### SQL methods
 
 These are methods written for easier sql usage.
@@ -101,6 +76,7 @@ obj.has_association?(:votes) #false
 </details>
 
 #### self.headache_sql(name, sql, opts = { })
+A better and safer way to write sql.
 with options: 
 - instantiate_class: returns User, Post, etc objects instead of straight sql output.
     I prefer doing the alterantive
@@ -109,7 +85,7 @@ with options:
 - prepare: sets whether the db will preprocess the strategy for lookup (defaults true) (have not verified the prepared-ness)
 - name_modifiers: allows one to change the preprocess associated name, useful in cases of dynamic sql.
 - multi_query: allows more than one query (you can seperate an insert and an update with ';' I dont know how else to say it.)
-    this disables other options (except name_modifiers). Not sure how it effects prepared statements.
+    this disables other options including arguments (except name_modifiers). Not sure how it effects prepared statements.
 - async: Gets passed to ActiveRecord::Base.connection.exec_query as a parameter. See that methods documentation for more. I was looking through the source code, and I think it only effects how it logs to the logfile?
 - other options: considered sql arguments
 
@@ -205,6 +181,31 @@ Preload :votes on some comments. :votes is an active record has_many relation.
     puts comments[0].votes #this line should be preloaded and hence not call the database
 ```
 </details>
+	
+### Hashed Global IDS
+
+hashed global ids look like this: "gid://meritfront/User/K9YI4K". They also have an optional tag so it can also look like "gid://meritfront/User/K9YI4K@user_image". They are based on global ids.
+
+I have been using hgids (Hashed Global IDs) for a while now and they have some unique benefits in front-end back-end communication. This is as they:
+1. hash the id which is good practice
+2. provide a way to have tags, this is good when updating different UI elements dynamically from the backend. For instance updating the @user_image without affecting the @user_name
+3. Carry the class with them, this can allow for more abstract and efficient code, and prevents id collisions between diffrent classes.
+
+#### methods from the hashid-rails gem
+
+See the hashid-rails gem for more (https://github.com/jcypret/hashid-rails). Also note that I aliased .hashid to .hid and .find_by_hashid to .hfind
+
+#### methods from this gem
+
+1. hgid(tag: nil) - get the hgid with optional tag. Aliased to ghid
+2. hgid_as_selector(str, attribute: 'id') - get a css selector for the hgid, good for updating the front-end (especially over cable-ready and morphdom operations)
+3. self.locate_hgid(hgid_string, with_associations: nil, returns_nil: false) - locates the database record from a hgid. Here are some examples of usage:
+    - ApplicationRecord.locate_hgid(hgid) - <b>DANGEROUS</b> will return any object referenced by the hgid.
+    - User.locate_hgid(hgid) - locates the User record but only if the hgid references a user class. Fires an error if not.
+    - ApplicationRecord.locate_hgid(hgid, with_associations: [:votes]) - locates the record but only if the  record's class has a :votes active record association. So for instance, you can accept only votable objects for upvote functionality. Fires an error if the hgid does not match.
+    - User.locate_hgid(hgid, returns_nil: true) - locates the hgid but only if it is the user class. Returns nil if not.
+4. get_hgid_tag(hgid) - returns the tag attached to the hgid
+5. self.blind_hgid(id, tag: nil, encode: true) - creates a hgid without bringing the object down from the database. Useful with hashid-rails encode_id and decode_id methods.
 
 ## Potential Issues
 
@@ -212,12 +213,19 @@ This gem was made with a postgresql database. Although most of the headache_sql
 
 Let me know if this actually becomes an issue for someone and I will throw in a workaround.
 
+## Next Up
+- I have the beginnings of something called swiss_instaload in mind, which will load multiple tables at the same time. For instance instead of Doing a ```usrs = User.all``` combined with a ```usrs.preload(:votes)```, which takes two sql requests, it could be done in one. Its kind of a crazy and dubious idea (efficiency wise), but I have a working prototype. It works by casting everything to json before returning it from the database. There might be a better way to do that long term though.
+- will be changing names from headache_* which is a bit negative to swiss_* as in swiss_army_knife which is known for its wide versitility. headache names will become aliases.
+	
 ## Changelog
 	
 1.1.10
 - Added functionality in headache_sql where for sql arguments that are equal, we only use one sql argument instead of repeating arguments
 - Added functionality in headache_sql for 'multi row expressions' which are inputtable as an Array of Arrays. See the upsert example in the headache_sql documentation above for more.
 - Added a warning in the README for non-postgresql databases. Contact me if you hit issues and we can work it out.
+
+1.1.11
+- Added encode option for blind_hgid to allow creation of just a general gid
 	
 ## Contributing
 

data/lib/dynamic-records-meritfront/version.rb

@@ -1,5 +1,5 @@
 
 	module DynamicRecordsMeritfront
-	    VERSION = '1.1.10'
+	    VERSION = '2.0.2'
 	end
 	#this file gets overwritten automatically on minor updates, major ones need to be manually changed

data/lib/dynamic-records-meritfront.rb

@@ -18,53 +18,56 @@ module DynamicRecordsMeritfront
 		#should work, probably able to override by redefining in ApplicationRecord class.
 		#Note we defined here as it breaks early on as Rails.application returns nil
 		PROJECT_NAME = Rails.application.class.to_s.split("::").first.to_s.downcase
+		DYNAMIC_SQL_RAW = true
+		attr_accessor :dynamic
 	end
 
-    class MultiRowExpression
-        #this class is meant to be used in congunction with headache_sql method
-        #Could be used like so in headache_sql:
-        
-        #ApplicationRecord.headache_sql( "teeeest", %Q{
-        #	INSERT INTO tests(id, username, is_awesome)
-        #	VALUES :rows
-        #	ON CONFLICT SET is_awesome = true
-        #}, rows: [[1, luke, true], [2, josh, false]])
-    
-        #which would output this sql
-    
-        #	INSERT INTO tests(id, username, is_awesome)
-        #	VALUES ($0,$1,$2),($3,$4,$5)
-        #	ON CONFLICT SET is_awesome = true
-    
-        attr_accessor :val
-        def initialize(val)
-            #assuming we are putting in an array of arrays.
-            self.val = val
-        end
-        def for_query(x = 0, unique_value_hash:)
-            #accepts x = current number of variables previously processed
-            #returns ["sql string with $# location information", variables themselves in order, new x]
-            db_val = val.map{|attribute_array| "(#{
-                attribute_index = 0
-                attribute_array.map{|attribute|
-                    prexist_num = unique_value_hash[attribute]
-                    if prexist_num
-                        attribute_array[attribute_index] = nil
-                        ret = "$#{prexist_num}"
-                    else
-                        unique_value_hash[attribute] = x
-                        ret = "$#{x}"
-                        x += 1
-                    end
-                    attribute_index += 1
-                    next ret
-                }.join(",")
-            })"}.join(",")
-            return db_val, val.flatten.select{|a| not a.nil?}, x
-        end
-    end
+	class MultiRowExpression
+		#this class is meant to be used in congunction with headache_sql method
+		#Could be used like so in headache_sql:
+		
+		#ApplicationRecord.headache_sql( "teeeest", %Q{
+		#	INSERT INTO tests(id, username, is_awesome)
+		#	VALUES :rows
+		#	ON CONFLICT SET is_awesome = true
+		#}, rows: [[1, luke, true], [2, josh, false]])
+	
+		#which would output this sql
+	
+		#	INSERT INTO tests(id, username, is_awesome)
+		#	VALUES ($0,$1,$2),($3,$4,$5)
+		#	ON CONFLICT SET is_awesome = true
+	
+		attr_accessor :val
+		def initialize(val)
+			#assuming we are putting in an array of arrays.
+			self.val = val
+		end
+		def for_query(x = 0, unique_value_hash:)
+			#accepts x = current number of variables previously processed
+			#returns ["sql string with $# location information", variables themselves in order, new x]
+			db_val = val.map{|attribute_array| "(#{
+				attribute_index = 0
+				attribute_array.map{|attribute|
+					prexist_num = unique_value_hash[attribute]
+					if prexist_num
+						attribute_array[attribute_index] = nil
+						ret = "$#{prexist_num}"
+					else
+						unique_value_hash[attribute] = x
+						ret = "$#{x}"
+						x += 1
+					end
+					attribute_index += 1
+					next ret
+				}.join(",")
+			})"}.join(",")
+			return db_val, val.flatten.select{|a| not a.nil?}, x
+		end
+	end
 
 	module ClassMethods
+
 		def has_run_migration?(nm)
 		#put in a string name of the class and it will say if it has allready run the migration.
 		#good during enum migrations as the code to migrate wont run if enumerate is there 
@@ -115,12 +118,10 @@ module DynamicRecordsMeritfront
 	
 			return migration_ran
 		end
-	
 		def list_associations
 			#lists associations (see has_association? below)
 			reflect_on_all_associations.map(&:name)
 		end
-
 		def has_association?(*args)
 			#checks whether current class has needed association (for example, checks it has comments)
 			#associations can be seen in has_many belongs_to and other similar methods
@@ -131,12 +132,11 @@ module DynamicRecordsMeritfront
 			args = args.flatten.map { |a| a.to_sym }
 			associations = list_associations
 			(args.length == (associations & args).length)
-		end
-		
-		def blind_hgid(id, tag: nil)
+		end		
+		def blind_hgid(id, tag: nil, encode: true)
 		# this method is to get an hgid for a class without actually calling it down from the database.
 		# For example Notification.blind_hgid 1 will give gid://PROJECT_NAME/Notification/69DAB69 etc.
-			unless id.class == String
+			if id.class == Integer and encode
 				id = self.encode_id id
 			end
 			gid = "gid://#{PROJECT_NAME}/#{self.to_s}/#{id}"
@@ -146,13 +146,11 @@ module DynamicRecordsMeritfront
 				"#{gid}@#{tag}"
 			end
 		end
-
 		def string_as_selector(str, attribute: 'id')
 			#this is needed to allow us to quey various strange characters in the id etc. (see hgids)
 			#also useful for querying various attributes
 			return "*[#{attribute}=\"#{str}\"]"
 		end
-	
 		def locate_hgid(hgid_string, with_associations: nil, returns_nil: false)
 			if hgid_string == nil or hgid_string.class != String
 				if returns_nil
@@ -199,7 +197,6 @@ module DynamicRecordsMeritfront
 				raise StandardError.new 'Not the expected class, or a subclass of ApplicationRecord if called on that.'
 			end
 		end
-	
 		def get_hgid_tag(hgid_string)
 			if hgid_string.include?('@')
 				return hgid_string.split('@')[-1]
@@ -242,138 +239,318 @@ module DynamicRecordsMeritfront
 			Array =>  Proc.new{ |first_el_class| ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(DB_TYPE_MAPS[first_el_class].new) }
 		}
 
-        def convert_to_query_attribute(name, v)
-            #yes its dumb I know dont look at me look at rails
-    
-            # https://stackoverflow.com/questions/40407700/rails-exec-query-bindings-ignored
-            # binds = [ ActiveRecord::Relation::QueryAttribute.new(
-            # 	"id", 6, ActiveRecord::Type::Integer.new
-            # )]
-            # ApplicationRecord.connection.exec_query(
-            # 	'SELECT * FROM users WHERE id = $1', 'sql', binds
-            # )
-    
-            return v if v.kind_of? ActiveRecord::Relation::QueryAttribute	#so users can have fine-grained control if they are trying to do something
-                #that we didn't handle properly.
-    
-            type = DB_TYPE_MAPS[v.class]
-            if type.nil?
-                raise StandardError.new("#{v}'s class #{v.class} unsupported type right now for ApplicationRecord#headache_sql")
-            elsif type.class == Proc
-                a = v[0]
-                # if a.nil?
-                # 	a = Integer
-                # elsif a.class == Array
-                a = a.nil? ? Integer : a.class
-                type = type.call(a)
-            else
-                type = type.new
-            end
-            
-            ActiveRecord::Relation::QueryAttribute.new( name, v, type )
-        end
-
+		def convert_to_query_attribute(name, v)
+			#yes its dumb I know dont look at me look at rails
+	
+			# https://stackoverflow.com/questions/40407700/rails-exec-query-bindings-ignored
+			# binds = [ ActiveRecord::Relation::QueryAttribute.new(
+			# 	"id", 6, ActiveRecord::Type::Integer.new
+			# )]
+			# ApplicationRecord.connection.exec_query(
+			# 	'SELECT * FROM users WHERE id = $1', 'sql', binds
+			# )
+	
+			return v if v.kind_of? ActiveRecord::Relation::QueryAttribute	#so users can have fine-grained control if they are trying to do something
+				#that we didn't handle properly.
+	
+			type = DB_TYPE_MAPS[v.class]
+			if type.nil?
+				raise StandardError.new("#{v}'s class #{v.class} unsupported type right now for ApplicationRecord#headache_sql")
+			elsif type.class == Proc
+				a = v[0]
+				# if a.nil?
+				# 	a = Integer
+				# elsif a.class == Array
+				a = a.nil? ? Integer : a.class
+				type = type.call(a)
+			else
+				type = type.new
+			end
+			
+			ActiveRecord::Relation::QueryAttribute.new( name, v, type )
+		end
 		#allows us to preload on a list and not a active record relation. So basically from the output of headache_sql
-		def headache_preload(records, associations)
+		def dynamic_preload(records, associations)
 			ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
 		end
 
-		def headache_sql(name, sql, opts = { }) #see below for opts
-            # - instantiate_class - returns User, Post, etc objects instead of straight sql output.
-            #		I prefer doing the alterantive
-            #			User.headache_class(...)
-            #		which is also supported
-            # - prepare sets whether the db will preprocess the strategy for lookup (defaults true) (I dont think turning this off works...)
-            # - name_modifiers allows one to change the preprocess associated name, useful in cases of dynamic sql.
-            # - multi_query allows more than one query (you can seperate an insert and an update with ';' I dont know how else to say it.)
-            #		this disables other options (except name_modifiers). Not sure how it effects prepared statements. Its a fairly useless
-            #		command as you can do multiple queries anyway with 'WITH' statements and also gain the other options.
-            # - async does what it says but I haven't used it yet so. Probabably doesn't work
-            #
-            # Any other option is assumed to be a sql argument (see other examples in code base)
-    
-            #grab options from the opts hash
-            instantiate_class = opts.delete(:instantiate_class)
-            name_modifiers = opts.delete(:name_modifiers)
-            name_modifiers ||= []
-            prepare = opts.delete(:prepare) != false
-            multi_query = opts.delete(:multi_query) == true
-            async = opts.delete(:async) == true
-            params = opts
-    
-            #unique value hash cuts down on the number of repeated arguments like in an update or insert statement
-            #by checking if there is an equal existing argument and then using that argument number instead.
-            #If this functionality is used at a lower level we should probably remove this.
-            unique_value_hash = {}
-    
-            #allows dynamic sql prepared statements.
-            for mod in name_modifiers
-                name << "_#{mod.to_s}" unless mod.nil?
-            end
-    
-            unless multi_query
-                #https://stackoverflow.com/questions/49947990/can-i-execute-a-raw-sql-query-leverage-prepared-statements-and-not-use-activer/67442353#67442353
-                #change the keys to $1, $2 etc. this step is needed for ex. {id: 1, id_user: 2}.
-                #doing the longer ones first prevents id replacing :id_user -> 1_user
-                keys = params.keys.sort{|a,b| b.to_s.length <=> a.to_s.length}
-                sql_vals = []
-                x = 1
-                for key in keys
-                    #replace the key with $1, $2 etc
-                    v = params[key]
-                    
-                    #this is where we guess what it is
-                    looks_like_multi_attribute_array = ((v.class == Array) and (not v.first.nil?) and (v.first.class == Array))
-    
-                    if v.class == MultiRowExpression or looks_like_multi_attribute_array
-                    #it looks like or is a multi-row expression (like those in an insert statement)
-                        v = MultiRowExpression.new(v) if looks_like_multi_attribute_array
-                        #process into usable information
-                        sql_for_replace, mat_vars, new_x = v.for_query(x, unique_value_hash: unique_value_hash)
-                        #replace the key with the sql
-                        if sql.gsub!(":#{key}", sql_for_replace) != nil
-                        #if successful set the new x number and append variables to our sql variables
-                            x = new_x
-                            name_num = 0
-                            mat_vars.each{|mat_var|
-                                name_num += 1
-                                sql_vals << convert_to_query_attribute("#{key}_#{name_num}", mat_var)
-                            }
-                        end
-                    else
-                        prexist_arg_num = unique_value_hash[v]
-                        if prexist_arg_num
-                            sql.gsub!(":#{key}", "$#{prexist_arg_num}")
-                        else
-                            if sql.gsub!(":#{key}", "$#{x}") == nil
-                                #nothing changed, param not used, delete it
-                                params.delete key
-                            else
-                                unique_value_hash[v] = x
-                                sql_vals << convert_to_query_attribute(key, v)
-                                x += 1
-                            end
-                        end
-                    end
-                end
-                ret = ActiveRecord::Base.connection.exec_query sql, name, sql_vals, prepare: prepare, async: async
-            else
-                ret = ActiveRecord::Base.connection.execute sql, name
-            end
-    
-            #this returns a PG::Result object, which is pretty basic. To make this into User/Post/etc objects we do
-                    #the following
-            if instantiate_class or self != ApplicationRecord
-                instantiate_class = self if not instantiate_class
-                #no I am not actually this cool see https://stackoverflow.com/questions/30826015/convert-pgresult-to-an-active-record-model
-                fields = ret.columns
-                vals = ret.rows
-                ret = vals.map { |v|
-                    instantiate_class.instantiate(Hash[fields.zip(v)])
-                }
-            end
-            ret
-        end
+		alias headache_preload dynamic_preload
+		
+		def dynamic_sql(name, sql, opts = { }) #see below for opts
+			# - instantiate_class - returns User, Post, etc objects instead of straight sql output.
+			#		I prefer doing the alterantive
+			#			User.headache_class(...)
+			#		which is also supported
+			# - prepare sets whether the db will preprocess the strategy for lookup (defaults true) (I dont think turning this off works...)
+			# - name_modifiers allows one to change the preprocess associated name, useful in cases of dynamic sql.
+			# - multi_query allows more than one query (you can seperate an insert and an update with ';' I dont know how else to say it.)
+			#		this disables other options (except name_modifiers). Not sure how it effects prepared statements. Its a fairly useless
+			#		command as you can do multiple queries anyway with 'WITH' statements and also gain the other options.
+			# - async does what it says but I haven't used it yet so. Probabably doesn't work
+			# - instaload is actually insane just look at the example in the readme yolo
+			#
+			# Any other option is assumed to be a sql argument (see other examples in code base)
+
+			#grab options from the opts hash
+			instantiate_class = opts.delete(:instantiate_class)
+			name_modifiers = opts.delete(:name_modifiers)
+			raw = opts.delete(:raw)
+			raw = DYNAMIC_SQL_RAW if raw.nil?
+			name_modifiers ||= []
+			prepare = opts.delete(:prepare) != false
+			multi_query = opts.delete(:multi_query) == true
+			async = opts.delete(:async) == true
+			params = opts
+
+			#unique value hash cuts down on the number of repeated arguments like in an update or insert statement
+			#by checking if there is an equal existing argument and then using that argument number instead.
+			#If this functionality is used at a lower level we should probably remove this.
+			unique_value_hash = {}
+
+			#allows dynamic sql prepared statements.
+			for mod in name_modifiers
+				name << "_#{mod.to_s}" unless mod.nil?
+			end
+
+			unless multi_query
+				#https://stackoverflow.com/questions/49947990/can-i-execute-a-raw-sql-query-leverage-prepared-statements-and-not-use-activer/67442353#67442353
+				#change the keys to $1, $2 etc. this step is needed for ex. {id: 1, id_user: 2}.
+				#doing the longer ones first prevents id replacing :id_user -> 1_user
+				keys = params.keys.sort{|a,b| b.to_s.length <=> a.to_s.length}
+				sql_vals = []
+				x = 1
+				for key in keys
+					#replace the key with $1, $2 etc
+					v = params[key]
+
+					#this is where we guess what it is
+					looks_like_multi_attribute_array = ((v.class == Array) and (not v.first.nil?) and (v.first.class == Array))
+
+					if v.class == MultiRowExpression or looks_like_multi_attribute_array
+					#it looks like or is a multi-row expression (like those in an insert statement)
+						v = MultiRowExpression.new(v) if looks_like_multi_attribute_array
+						#process into usable information
+						sql_for_replace, mat_vars, new_x = v.for_query(x, unique_value_hash: unique_value_hash)
+						#replace the key with the sql
+						if sql.gsub!(":#{key}", sql_for_replace) != nil
+						#if successful set the new x number and append variables to our sql variables
+							x = new_x
+							name_num = 0
+							mat_vars.each{|mat_var|
+								name_num += 1
+								sql_vals << convert_to_query_attribute("#{key}_#{name_num}", mat_var)
+							}
+						end
+					else
+						prexist_arg_num = unique_value_hash[v]
+						if prexist_arg_num
+							sql.gsub!(":#{key}", "$#{prexist_arg_num}")
+						else
+							if sql.gsub!(":#{key}", "$#{x}") == nil
+								#nothing changed, param not used, delete it
+								params.delete key
+							else
+								unique_value_hash[v] = x
+								sql_vals << convert_to_query_attribute(key, v)
+								x += 1
+							end
+						end
+					end
+				end
+				ret = ActiveRecord::Base.connection.exec_query sql, name, sql_vals, prepare: prepare, async: async
+			else
+				ret = ActiveRecord::Base.connection.execute sql, name
+			end
+
+			#this returns a PG::Result object, which is pretty basic. To make this into User/Post/etc objects we do
+					#the following
+			if instantiate_class or not self.abstract_class
+				instantiate_class = self if not instantiate_class
+				#no I am not actually this cool see https://stackoverflow.com/questions/30826015/convert-pgresult-to-an-active-record-model
+				ret = zip_ar_result(ret)
+				return ret.map{|r| dynamic_init(instantiate_class, r)}
+				# fields = ret.columns
+				# vals = ret.rows
+				# ret = vals.map { |v|
+				# 	dynamic_init()
+				# 	instantiate_class.instantiate(Hash[fields.zip(v)])
+				# }
+			else
+				if raw
+					return ret
+				else
+					return zip_ar_result(ret)
+				end
+			end
+		end
+		alias headache_sql dynamic_sql
+		
+		def instaload(sql, table_name: nil, relied_on: false)
+			table_name ||= "_" + self.to_s.underscore.downcase.pluralize
+			klass = self.to_s
+			sql = "\t" + sql.strip
+			return {table_name: table_name, klass: klass, sql: sql, relied_on: relied_on}
+		end
+
+		def _dynamic_instaload_handle_with_statements(with_statements)
+			%Q{WITH #{
+	with_statements.map{|ws|
+		"#{ws[:table_name]} AS (\n#{ws[:sql]}\n)"
+	}.join(", \n")
+}}
+		end
+
+		def _dynamic_instaload_union(insta_array)
+			insta_array.map{|insta|
+				start = "SELECT row_to_json(#{insta[:table_name]}.*) AS row, '#{insta[:klass]}' AS _klass, '#{insta[:table_name]}' AS _table_name FROM "
+				if insta[:relied_on]
+					ending = "#{insta[:table_name]}\n"
+				else
+					ending = "(\n#{insta[:sql]}\n) AS #{insta[:table_name]}\n"
+				end
+				next start + ending
+			}.join(" UNION ALL \n")
+			#{ other_statements.map{|os| "SELECT row_to_json(#{os[:table_name]}.*) AS row, '#{os[:klass]}' AS _klass FROM (\n#{os[:sql]}\n)) AS #{os[:table_name]}\n" }.join(' UNION ALL ')}
+		end
+
+		def dynamic_instaload_sql(name, insta_array, opts = { })
+			with_statements = insta_array.select{|a| a[:relied_on]}
+			sql = %Q{
+#{ _dynamic_instaload_handle_with_statements(with_statements) if with_statements.any? }
+#{ _dynamic_instaload_union(insta_array)}
+}
+			ret_hash = insta_array.map{|ar| [ar[:table_name].to_s, []]}.to_h
+			ApplicationRecord.headache_sql(name, sql, opts).rows.each{|row|
+				#need to pre-parsed as it has a non-normal output.
+				table_name = row[2]
+				klass = row[1].constantize
+				json = row[0]
+				parsed = JSON.parse(json)
+
+				ret_hash[table_name ].push dynamic_init(klass, parsed)
+			}
+			return ret_hash
+		end
+		alias swiss_instaload_sql dynamic_instaload_sql
+
+		def dynamic_attach(instaload_sql_output, base_name, attach_name, base_on: nil, attach_on: nil, one_to_one: false, debug: false)
+			base_arr = instaload_sql_output[base_name]
+			
+			#return if there is nothing for us to attach to.
+			return unless base_arr.any?
+
+			#set variables for neatness and so we dont compute each time
+			#	base class information
+			base_class = base_arr.first.class
+			base_class_is_hash = base_class <= Hash
+			#	attach name information for variables
+			attach_name_sym = attach_name.to_sym
+			attach_name_with_at = "@#{attach_name}"
+			
+			#variable accessors and defaults.
+			base_arr.each{|o|
+				o.singleton_class.public_send(:attr_accessor, attach_name_sym) unless base_class_is_hash
+				o.instance_variable_set(attach_name_with_at, []) unless one_to_one
+			}
+
+			#make sure the attach class has something going on
+			attach_arr = instaload_sql_output[attach_name]
+			return unless attach_arr.any?
+			
+			#	attach class information
+			attach_class = attach_arr.first.class
+			attach_class_is_hash = attach_class <= Hash
+
+			#	default attach column info
+			default_attach_col = (base_class.to_s.downcase + "_id")
+
+			#decide on the method of getting the matching id for the base table
+			unless base_on
+				if base_class_is_hash
+					base_on = Proc.new{|x| x['id']}
+				else
+					base_on = Proc.new{|x| x.id}
+				end
+			end
+
+			#return an id->object hash for the base table for better access
+			h = base_arr.map{|o| 
+				[base_on.call(o), o]
+			}.to_h
+			
+			#decide on the method of getting the matching id for the attach table
+			unless attach_on
+				if attach_class_is_hash
+					attach_on = Proc.new{|x| x[default_attach_col]}
+				else
+					attach_on = Proc.new{|x| 
+							x.method(default_attach_col).call
+					}
+				end
+			end
+
+			# if debug
+			# 	Rails.logger.info(base_arr.map{|b|
+			# 		base_on.call(b)
+			# 	})
+			# 	Rails.logger.info(attach_arr.map{|a|
+			# 		attach_on.call(a)
+			# 	})
+			# end
+
+			#method of adding the object to the base
+			#(b=base, a=attach)
+			add_to_base = Proc.new{|b, a|
+				if one_to_one
+					if base_class_is_hash
+						b[attach_name] = a
+					else
+						b.instance_variable_set(attach_name_with_at, a)
+					end
+				else
+					if base_class_is_hash
+						b[attach_name].push a
+					else
+						b.instance_variable_get(attach_name_with_at).push a
+					end
+				end
+			}
+
+			#for every attachable
+			#	1. match base id to the attach id (both configurable)
+			#	2. cancel out if there is no match
+			#	3. otherwise add to the base object.
+			attach_arr.each{|attach|
+				if out = attach_on.call(attach) #you can use null to escape the vals
+					if base = h[out] #it is also escaped if no base element is found
+						add_to_base.call(base, attach)
+					end
+				end
+			}
+			return attach_arr
+		end
+		alias swiss_attach dynamic_attach
+
+		def zip_ar_result(x)
+			fields = x.columns
+			vals = x.rows
+			vals.map { |v|
+				Hash[fields.zip(v)]
+			}
+		end
+
+		def dynamic_init(klass, input)
+			if klass.abstract_class
+				return input
+			else
+				#handle attributes through ar if allowed. Throws an error on unkown variables, except apparently for devise classes? 😡
+				active_record_handled = input.slice(*(klass.attribute_names & input.keys))
+				record = klass.instantiate(active_record_handled)
+				#set those that were not necessarily expected
+				record.dynamic = input.slice(*(input.keys - klass.attribute_names)).transform_keys{|k|k.to_sym}
+				return record
+			end
+		end
 
 		def quick_safe_increment(id, col, val)
 			where(id: id).update_all("#{col} = #{col} + #{val}")
@@ -415,4 +592,4 @@ module DynamicRecordsMeritfront
 		self.class.where(id: self.id).update_all("#{col} = #{col} + #{val}")
 	end
 
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic-records-meritfront
 version: !ruby/object:Gem::Version
-  version: 1.1.10
+  version: 2.0.2
 platform: ruby
 authors:
 - Luke Clancy
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-10-13 00:00:00.000000000 Z
+date: 2022-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashid-rails