dynamic-records-meritfront 1.1.8 → 1.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9e6bb65327dba67618a5b1169062f99cabe4058ce81d0bd18da182f11b75fd8f
-  data.tar.gz: 6337505ce72c61690796a54812977d931c48a96bdf493a4bdb9ade74195d7293
+  metadata.gz: 549b1d707e2419d0444845f8c15cd1564572c0ca68a72bf208a39be116feb5f3
+  data.tar.gz: 5641ddc311be64741db802cc638b73b586be91d30edcdc171fc04949b3f57542
 SHA512:
-  metadata.gz: 0a0eaf0b5886ac66c1df34dac9f627b84a9d8bd1119d1f5e37070364faff2421da21b84480fc2376061c13109cabc6e7f0735d528ba730e1d6400d552fff6ac6
-  data.tar.gz: 8329c93e4a222ad762a96aff9a4e403f3614e14de277d790bad973bf3baf46e825795bed571928cc52e97937d97e8836eed327b930a790d9e771fb7a154151a1
+  metadata.gz: dc0a7c85bbb2ca8cdfd931c5ae9002c319809658d1437f68d3c4356758d71a5db7e277e2bcb87caa37b44608f13bc7a1c0fd38ad0e2aeb7bcc4de3a262519e28
+  data.tar.gz: ce81fa5af8b092b10be95b3134b37051a321df53434220bca3ebbb9815b260f3fcba698891282eba179f04c22090466251c0d5a3f3e1e48d6e903b75e5197ce7

data/Gemfile.lock

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

data/README.md

@@ -11,7 +11,7 @@ I dont tend to get much feedback, so any given would be appreciated.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'active_record_meritfront'
+gem 'dynamic-records-meritfront'
 ```
 
 And then execute:
@@ -20,10 +20,19 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install active_record_meritfront
+    $ gem install dynamic-records-meritfront
 
 ## Usage
 
+### Apply to your ApplicationRecord class as such
+
+```ruby
+class ApplicationRecord < ActiveRecord::Base
+	self.abstract_class = true
+	include DynamicRecordsMeritfront
+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.
@@ -40,14 +49,14 @@ See the hashid-rails gem for more (https://github.com/jcypret/hashid-rails). Als
 #### 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
+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 
+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
 
@@ -101,7 +110,7 @@ with options:
 - 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.
-- async: does what it says but I haven't used it yet so. Probabably doesn't work
+- 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
 
 <details>
@@ -118,7 +127,7 @@ Delete Friend Requests between two users after they have become friends.
 </details>
 
 <details>
-<summary>advanced example usage</summary>
+<summary>dynamic sql example usage</summary>
 Get all users who have made a friend request to a particular user with an optional limit.
 This is an example of why this method is good for dynamic prepared statements.
 
@@ -138,13 +147,81 @@ This is an example of why this method is good for dynamic prepared statements.
     ])
 ```
 </details>
+<details>
+<summary>example usage with selecting records that match list of ids</summary>
+Get users who match a list of ids. Uses a postgresql Array, see the potential issues section
+
+```ruby
+	id_list = [1,2,3]
+	return User.headache_sql('get_usrs', %Q{
+		SELECT * FROM users WHERE id = ANY (:id_list)
+	}, id_list: id_list)
+```
+</details>
+	
+<details>
+<summary>example usage a custom upsert</summary>
+Do an upsert
+
+```ruby
+	rows = uzrs.map{|u| [
+		u.id,		#user_id
+		self.id,	#conversation_id
+		from,		#invited_by
+		t,		#created_at
+		t,		#updated_at
+	]}
+	ApplicationRecord.headache_sql("upsert_conversation_invites_2", %Q{
+		INSERT INTO conversation_participants (user_id, conversation_id, invited_by, created_at, updated_at)
+		VALUES :rows
+		ON CONFLICT (conversation_id,user_id)
+		DO UPDATE SET updated_at = :time
+	}, rows: rows, time: t)
+```
+This will output sql similar to below. Note this can be done for multiple conversation_participants. Also note that it only sent one time variable as an argument as headache_sql detected that we were sending duplicate information.
+```sql
+	INSERT INTO conversation_participants (user_id, conversation_id, invited_by, created_at, updated_at)
+	VALUES ($1,$2,$3,$4,$4)
+	ON CONFLICT (conversation_id,user_id)
+	DO UPDATE SET updated_at = $4
+	-- [["rows_1", 15], ["rows_2", 67], ["rows_3", 6], ["rows_4", "2022-10-13 20:49:27.441372"]]
+```
+</details>
+	
+	
 
 #### self.headache_preload(records, associations)
-Preloads from a list of records, and not from a ActiveRecord_Relation. This will be useful when using the above headache_sql method.
+Preloads from a list of records, and not from a ActiveRecord_Relation. This will be useful when using the above headache_sql method (as it returns a list of records, and not a record relation).
+
+<details>
+<summary>example usage</summary>
+Preload :votes on some comments. :votes is an active record has_many relation.
+
+```ruby
+    comments = Comment.headache_sql('get_comments', %Q{
+        SELECT * FROM comments LIMIT 4
+    })
+    ApplicationRecord.headache_preload(comments, [:votes])
+    puts comments[0].votes #this line should be preloaded and hence not call the database
+```
+</details>
+
+## Potential Issues
+
+This gem was made with a postgresql database. Although most of the headache_sql code <i>should</i> be usable between databases, there is no abstracted ActiveRecord array type, and no similar classes to ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array for non-postgresql databases (at least, none I could find). I am not 100% sure that it will be an issue, but it might be.
+
+Let me know if this actually becomes an issue for someone and I will throw in a workaround.
 
+## 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.
+	
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/active_record_meritfront. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/active_record_meritfront/blob/master/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/LukeClancy/dynamic-records-meritfront. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/LukeClancy/dynamic-records-meritfront/blob/master/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -152,4 +229,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the ActiveRecordMeritfront project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/active_record_meritfront/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the ActiveRecordMeritfront project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/LukeClancy/dynamic-records-meritfront/blob/master/CODE_OF_CONDUCT.md).

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

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

data/lib/dynamic-records-meritfront.rb

@@ -2,7 +2,7 @@ require "dynamic-records-meritfront/version"
 require 'hashid/rails'
 
 module DynamicRecordsMeritfront
-    extend ActiveSupport::Concern
+	extend ActiveSupport::Concern
 
 	# the two aliases so I dont go insane
 	module Hashid::Rails
@@ -12,199 +12,273 @@ module DynamicRecordsMeritfront
 		alias hfind find_by_hashid
 	end
 
-    included do
-        # include hash id gem
-	    include Hashid::Rails
-        #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
-    end
+	included do
+		# include hash id gem
+		include Hashid::Rails
+		#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
+	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 
-        #as it is not yet enumerated (causing an error when it loads the class that will have the
-        #enumeration in it). This can lead it to being impossible to commit clean code.
-        #
-        # example usage one: only create the record class if it currently exists in the database
-            # if ApplicationRecord.has_run_migration?('UserImageRelationsTwo')
-            # 	class UserImageRelation < ApplicationRecord
-            # 		belongs_to :imageable, polymorphic: true
-            # 		belongs_to :image
-            # 	end
-            # else
-            # 	class UserImageRelation; end
-            # end
-        # example usage two: only load relation if it exists in the database
-            # class UserImageRelation < ApplicationRecord
-            #	if ApplicationRecord.has_run_migration?('UserImageRelationsTwo')
-            #	 	belongs_to :imageable, polymorphic: true
-            #	end
-            # end
-        #	
-            #current version of migrations
-            cv = ActiveRecord::Base.connection.migration_context.current_version
-            
-            #find the migration object for the name
-            migration = ActiveRecord::Base.connection.migration_context.migrations.filter!{|a|
-                    a.name == nm
-                }.first
-            
-            #if the migration object is nil, it has not yet been created
-            if migration.nil?
-                Rails.logger.info "No migration found for #{nm}. The migration has not yet been created, or is foreign to this database."
-                return false
-            end
-    
-            #get the version number for the migration name
-            needed_version = migration.version
+    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]])
     
-            #if current version is above or equal, the migration has allready been run
-            migration_ran = (cv >= needed_version)
+        #which would output this sql
     
-            if migration_ran
-                Rails.logger.info "#{nm} migration was run on #{needed_version}. If old and all instances are migrated, consider removing code check."
-            else
-                Rails.logger.info "#{nm} migration has not run yet. This may lead to limited functionality"
-            end
+        #	INSERT INTO tests(id, username, is_awesome)
+        #	VALUES ($0,$1,$2),($3,$4,$5)
+        #	ON CONFLICT SET is_awesome = true
     
-            return migration_ran
+        attr_accessor :val
+        def initialize(val)
+            #assuming we are putting in an array of arrays.
+            self.val = val
         end
-    
-        def list_associations
-            #lists associations (see has_association? below)
-            reflect_on_all_associations.map(&:name)
+        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
 
-        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
+	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 
+		#as it is not yet enumerated (causing an error when it loads the class that will have the
+		#enumeration in it). This can lead it to being impossible to commit clean code.
+		#
+		# example usage one: only create the record class if it currently exists in the database
+			# if ApplicationRecord.has_run_migration?('UserImageRelationsTwo')
+			# 	class UserImageRelation < ApplicationRecord
+			# 		belongs_to :imageable, polymorphic: true
+			# 		belongs_to :image
+			# 	end
+			# else
+			# 	class UserImageRelation; end
+			# end
+		# example usage two: only load relation if it exists in the database
+			# class UserImageRelation < ApplicationRecord
+			#	if ApplicationRecord.has_run_migration?('UserImageRelationsTwo')
+			#	 	belongs_to :imageable, polymorphic: true
+			#	end
+			# end
+		#	
+			#current version of migrations
+			cv = ActiveRecord::Base.connection.migration_context.current_version
+			
+			#find the migration object for the name
+			migration = ActiveRecord::Base.connection.migration_context.migrations.filter!{|a|
+					a.name == nm
+				}.first
+			
+			#if the migration object is nil, it has not yet been created
+			if migration.nil?
+				Rails.logger.info "No migration found for #{nm}. The migration has not yet been created, or is foreign to this database."
+				return false
+			end
+	
+			#get the version number for the migration name
+			needed_version = migration.version
+	
+			#if current version is above or equal, the migration has allready been run
+			migration_ran = (cv >= needed_version)
+	
+			if migration_ran
+				Rails.logger.info "#{nm} migration was run on #{needed_version}. If old and all instances are migrated, consider removing code check."
+			else
+				Rails.logger.info "#{nm} migration has not run yet. This may lead to limited functionality"
+			end
+	
+			return migration_ran
+		end
+	
+		def list_associations
+			#lists associations (see has_association? below)
+			reflect_on_all_associations.map(&:name)
+		end
 
-            #flattens so you can pass self.has_association?(:comments, :baseable_comments) aswell as
-            #		self.has_association?([:comments, :baseable_comments]) without issue
-            #		
-            args = args.flatten.map { |a| a.to_sym }
-            associations = list_associations
-            (args.length == (associations & args).length)
-        end
-        
-        def blind_hgid(id, tag: nil)
-        # 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
-                id = self.encode_id id
-            end
-            gid = "gid://#{PROJECT_NAME}/#{self.to_s}/#{id}"
-            if !tag
-                gid
-            else
-                "#{gid}@#{tag}"
-            end
-        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
 
-        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
-                    return nil
-                else
-                    raise StandardError.new("non-string class passed to ApplicationRecord#locate_hgid as the hgid_string variable")
-                end
-            end
-            if hgid_string.include?('@')
-                hgid_string = hgid_string.split('@')
-                hgid_string.pop
-                hgid_string = hgid_string.join('@') # incase the model was a tag that was tagged. (few months later: Wtf? Guess ill keep it)
-            end
-            #split the thing
-            splitz = hgid_string.split('/')
-            #get the class
-            begin
-                cls = splitz[-2].constantize
-            rescue NameError, NoMethodError
-                if returns_nil
-                    nil
-                else
-                    raise StandardError.new 'Unusual or unavailable string or hgid'
-                end
-            end
-            #get the hash
-            hash = splitz[-1]
-            # if self == ApplicationRecord (for instance), then check that cls is a subclass
-            # if self is not ApplicationRecord, then check cls == this objects class
-            # if with_associations defined, make sure that the class has the associations given (see has_association above)
-            if ((self.abstract_class? and cls < self) or ( (not self.abstract_class?) and cls == self )) and
-                ( with_associations == nil or cls.has_association?(with_associations) )
-                #if all is as expected, return the object with its id.
-                if block_given?
-                    yield(hash)
-                else
-                    cls.hfind(hash)
-                end
-            elsif returns_nil
-                #allows us to handle issues with input
-                nil
-            else
-                #stops execution as default
-                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]
-            else
-                return nil
-            end
-        end
+			#flattens so you can pass self.has_association?(:comments, :baseable_comments) aswell as
+			#		self.has_association?([:comments, :baseable_comments]) without issue
+			#		
+			args = args.flatten.map { |a| a.to_sym }
+			associations = list_associations
+			(args.length == (associations & args).length)
+		end
+		
+		def blind_hgid(id, tag: nil)
+		# 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
+				id = self.encode_id id
+			end
+			gid = "gid://#{PROJECT_NAME}/#{self.to_s}/#{id}"
+			if !tag
+				gid
+			else
+				"#{gid}@#{tag}"
+			end
+		end
 
-        #thank god for some stack overflow people are pretty awesome https://stackoverflow.com/questions/64894375/executing-a-raw-sql-query-in-rails-with-an-array-parameter-against-postgresql
-        #BigIntArray = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(ActiveModel::Type::BigInteger.new).freeze
-        #IntegerArray = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(ActiveModel::Type::Integer.new).freeze
+		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
+					return nil
+				else
+					raise StandardError.new("non-string class passed to ApplicationRecord#locate_hgid as the hgid_string variable")
+				end
+			end
+			if hgid_string.include?('@')
+				hgid_string = hgid_string.split('@')
+				hgid_string.pop
+				hgid_string = hgid_string.join('@') # incase the model was a tag that was tagged. (few months later: Wtf? Guess ill keep it)
+			end
+			#split the thing
+			splitz = hgid_string.split('/')
+			#get the class
+			begin
+				cls = splitz[-2].constantize
+			rescue NameError, NoMethodError
+				if returns_nil
+					nil
+				else
+					raise StandardError.new 'Unusual or unavailable string or hgid'
+				end
+			end
+			#get the hash
+			hash = splitz[-1]
+			# if self == ApplicationRecord (for instance), then check that cls is a subclass
+			# if self is not ApplicationRecord, then check cls == this objects class
+			# if with_associations defined, make sure that the class has the associations given (see has_association above)
+			if ((self.abstract_class? and cls < self) or ( (not self.abstract_class?) and cls == self )) and
+				( with_associations == nil or cls.has_association?(with_associations) )
+				#if all is as expected, return the object with its id.
+				if block_given?
+					yield(hash)
+				else
+					cls.hfind(hash)
+				end
+			elsif returns_nil
+				#allows us to handle issues with input
+				nil
+			else
+				#stops execution as default
+				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]
+			else
+				return nil
+			end
+		end
 
-        #https://api.rubyonrails.org/files/activemodel/lib/active_model/type_rb.html
-        # active_model/type/helpers
-        # active_model/type/value
-        # active_model/type/big_integer
-        # active_model/type/binary
-        # active_model/type/boolean
-        # active_model/type/date
-        # active_model/type/date_time
-        # active_model/type/decimal
-        # active_model/type/float
-        # active_model/type/immutable_string
-        # active_model/type/integer
-        # active_model/type/string
-        # active_model/type/time
-        # active_model
+		#thank god for some stack overflow people are pretty awesome https://stackoverflow.com/questions/64894375/executing-a-raw-sql-query-in-rails-with-an-array-parameter-against-postgresql
+		#BigIntArray = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(ActiveModel::Type::BigInteger.new).freeze
+		#IntegerArray = ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(ActiveModel::Type::Integer.new).freeze
 
-        DB_TYPE_MAPS = {
-            String => ActiveModel::Type::String,
-            Symbol => ActiveModel::Type::String,
-            Integer => ActiveModel::Type::BigInteger,
-            BigDecimal => ActiveRecord::Type::Decimal,
-            TrueClass => ActiveModel::Type::Boolean,
-            FalseClass => ActiveModel::Type::Boolean,
-            Date => ActiveModel::Type::Date,
-            DateTime => ActiveModel::Type::DateTime,
-            Time => ActiveModel::Type::Time,
-            Float => ActiveModel::Type::Float,
-            Array =>  Proc.new{ |first_el_class| ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(DB_TYPE_MAPS[first_el_class].new) }
-        }
+		#https://api.rubyonrails.org/files/activemodel/lib/active_model/type_rb.html
+		# active_model/type/helpers
+		# active_model/type/value
+		# active_model/type/big_integer
+		# active_model/type/binary
+		# active_model/type/boolean
+		# active_model/type/date
+		# active_model/type/date_time
+		# active_model/type/decimal
+		# active_model/type/float
+		# active_model/type/immutable_string
+		# active_model/type/integer
+		# active_model/type/string
+		# active_model/type/time
+		# active_model
 
+		DB_TYPE_MAPS = {
+			String => ActiveModel::Type::String,
+			Symbol => ActiveModel::Type::String,
+			Integer => ActiveModel::Type::BigInteger,
+			BigDecimal => ActiveRecord::Type::Decimal,
+			TrueClass => ActiveModel::Type::Boolean,
+			FalseClass => ActiveModel::Type::Boolean,
+			Date => ActiveModel::Type::Date,
+			DateTime => ActiveModel::Type::DateTime,
+			Time => ActiveModel::Type::Time,
+			Float => ActiveModel::Type::Float,
+			Array =>  Proc.new{ |first_el_class| ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(DB_TYPE_MAPS[first_el_class].new) }
+		}
 
-        #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)
-            ActiveRecord::Associations::Preloader.new(records: records, associations: associations).call
+        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 headache_sql(name, sql, opts = { }) #see below for opts
+		#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)
+			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(...)
@@ -212,11 +286,12 @@ module DynamicRecordsMeritfront
             # - 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.
+            #		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)
@@ -225,74 +300,85 @@ module DynamicRecordsMeritfront
             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}
-                vals = []
+                sql_vals = []
                 x = 1
                 for key in keys
                     #replace the key with $1, $2 etc
-                    if sql.gsub!(":#{key}", "$#{x}") == nil
-                        #nothing changed, param not used, delete it
-                        x -= 1
-                        params.delete key
+                    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
-                        #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
-                        # )
-                        v = params[key]
-                        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]
-                            a.nil? ? a = Integer : a = a.class
-                            type = type.call(a)
+                        prexist_arg_num = unique_value_hash[v]
+                        if prexist_arg_num
+                            sql.gsub!(":#{key}", "$#{prexist_arg_num}")
                         else
-                            type = type.new
+                            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
-                        
-                        vals << ActiveRecord::Relation::QueryAttribute.new( key, v, type )
                     end
-                    x += 1
                 end
-                ret = ActiveRecord::Base.connection.exec_query sql, name, vals, prepare: prepare, async: async
+                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)])
-                            }
+                #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
-        def quick_safe_increment(id, col, val)
-            where(id: id).update_all("#{col} = #{col} + #{val}")
-        end
-    end
+
+		def quick_safe_increment(id, col, val)
+			where(id: id).update_all("#{col} = #{col} + #{val}")
+		end
+	end
 
 	def list_associations
 		#lists associations (see class method above)
@@ -321,11 +407,10 @@ module DynamicRecordsMeritfront
 		return self.class.string_as_selector(gidstr, attribute: attribute)
 	end
 
-    #just for ease of use
-    def headache_preload(records, associations)
-        self.class.headache_preload(records, associations)
-    end
-
+	#just for ease of use
+	def headache_preload(records, associations)
+			self.class.headache_preload(records, associations)
+	end
 	def safe_increment(col, val) #also used in follow, also used in comment#kill
 		self.class.where(id: self.id).update_all("#{col} = #{col} + #{val}")
 	end

metadata

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