dynamic-records-meritfront 3.0.3 → 3.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15173d17ad833e673910fc87f1dd1c6801105086f9a36e2042154c3e624fbc50
-  data.tar.gz: 171e89a86eef3b0f75a92a75b4226ab401eda42ad9dd83bb4bed16b92ae439db
+  metadata.gz: c0b267bcbccbdacef50a52ad1880100ee74e644224acc0a6602b89b3b61cf4b8
+  data.tar.gz: 6335a84f567063727283fc2e87420f1d1020564aa412b699fb9bc8f48f4a1bb1
 SHA512:
-  metadata.gz: 20cae9b9c791929d29002d171a837291c1e9315dc9bbb6b4a408212dd98ce408aae270a1b52caeb91f73995ac086e4ff9afd771b9a2a51878bea400881141c88
-  data.tar.gz: 551ef2074974ae385c9759ac58c2c170faeb835ed87ca166d7ccfe38779b6f2d03d2f3a3fc06c53e3a05c38a93ccf014a240f13a7b78eb227810d8fcc5928151
+  metadata.gz: 8a130aa5128a8c25ed5f484035257f8d69ce5b3507bb6598bd9396a6396f1ff29fa0ff474e28a6ea92e3b22152060bea0857413e9c546c2472e41825258e8519
+  data.tar.gz: fb3cdfb3901573ba28a9b20240af8e0714b4440a7caf7c4d8abbaf024629faadd3fcb17ad126f392232cc681fd176de89ed045c4e90f5bf9da59a00ba89b96df

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dynamic-records-meritfront (3.0.3)
+    dynamic-records-meritfront (3.0.11)
       hashid-rails
 
 GEM
@@ -24,7 +24,7 @@ GEM
     hashids (1.0.6)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
-    minitest (5.16.3)
+    minitest (5.17.0)
     rake (12.3.3)
     tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)

data/README.md

@@ -45,16 +45,12 @@ Or install it yourself as:
 
 ## Usage
 
-### Apply to your ApplicationRecord class as such
+### Apply to your ApplicationRecord class as such (or whatever subclass of ActiveRecord::Base you have)
 
 ```ruby
 class ApplicationRecord < ActiveRecord::Base
 	self.abstract_class = true
 	include DynamicRecordsMeritfront
-	
-	#DYNAMIC_SQL_RAW determines whether dynamic_sql method returns a ActiveRecord::Response object or an Array.
-	#They both have pros and cons. False returns the array.
-	DynamicRecordsMeritfront::DYNAMIC_SQL_RAW = false
 end
 ```
 
@@ -67,15 +63,11 @@ A better and safer way to write sql. Can return either a Hash, ActiveRecord::Res
 
 ```ruby
 User.dynamic_sql('select * from users')	#returns all users
-ApplicationRecord.dynamic_sql('select id from users', raw: true).rows.flatten #get just the users ids
+ApplicationRecord.dynamic_sql('select * from users') #returns all user column information in an array
 ```
 
 with options: 
 - options not stated below: considered sql arguments, and will replace their ":option_name" with a sql argument. Always use sql arguments to avoid sql injection. Lists are converted into a format such as ```{1,2,3,4}```. Lists of lists are converted into ```(1,2,3), (4,5,6), (7,8,9)``` etc. So as to allow easy inserts/upserts.
-- raw: whether to return a ActiveRecord::Response object or a hash when called on an abstract class (like ApplicationRecord). Default can be switched with DYNAMIC_SQL_RAW variable on the class level.
-
-other less critical options:
-
 - prepare: Defaults to true. Gets passed to ActiveRecord::Base.connection.exec_query as a parameter. Should change whether the command will be prepared, which means that on subsequent calls the command will be faster. Downsides are when, for example, the sql query has hard-coded arguments, the query always changes, causing technical issues as the number of prepared statements stack up.
 - 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 including sql_arguments. Not sure how it effects prepared statements. Not super useful.
@@ -149,27 +141,28 @@ Get users who match a list of ids. Uses a postgresql Array, see the potential is
 Do an upsert
 
 ```ruby
+	time = DateTime.now
 	rows = uzrs.map{|u| [
 		u.id,		#user_id
 		self.id,	#conversation_id
 		from,		#invited_by
-		t,		#created_at
-		t,		#updated_at
+		:time,		#created_at		(We use symbols to denote other sql arguments)
+		:time,		#updated_at
 	]}
 	ApplicationRecord.dynamic_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)
+	}, rows: rows, time: time)
 ```
-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 dynamic_sql detected that we were sending duplicate information.
+This will output sql similar to below. Note this can be done for multiple conversation_participants. Also note that we sent only one time variable during our request instead of duplicating it.
 ```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"]]
+	-- [["rows_1", 15], ["rows_2", 67], ["rows_3", 6], [:time, "2022-10-13 20:49:27.441372"]]
 ```
 </details>
 	
@@ -244,10 +237,10 @@ obj.has_association?(:votes) #false
 ```
 </details>
 
-#### self.dynamic_instaload_sql( *optional* name, insta_array, opts = { })
+#### self.instaload_sql( *optional* name, insta_array, opts = { })
 *instaloads* a bunch of diffrent models at the same time by casting them to json before returning them. Kinda cool. Maybe a bit overcomplicated. Seems to be more efficient to preloading when i tested it.
 - name is passed to dynamic_sql and is the name of the sql request
-- opts are passed to dynamic_sql (except for the raw option which is set to true. Raw output is not allowed on this request)
+- opts are passed to dynamic_sql
 - requires a list of instaload method output which provides information for how to treat each sql block.
 
 ```ruby
@@ -264,7 +257,7 @@ out = ApplicationRecord.instaload_sql([
 
 ```ruby
    # the ruby entered
-   output = ApplicationRecord.dynamic_instaload_sql([
+   output = ApplicationRecord.instaload_sql([
       User.instaload('SELECT id FROM users WHERE users.id = ANY (:user_ids) AND users.created_at > :time', table_name: 'limited_users', relied_on: true),
       User.instaload(%Q{
          SELECT friends.smaller_user_id AS id, friends.bigger_user_id AS friended_to
@@ -323,7 +316,7 @@ the output:
 </details>
 	
 #### self.instaload(sql, table_name: nil, relied_on: false, dont_return: false)
-A method used to prepare data for the dynamic_instaload_sql method. It returns a hash of options.
+A method used to prepare data for the instaload_sql method. It returns a hash of options.
 - klass called on: if called on an abstract class (ApplicationRecord) it will return a list of hashes with the data. Otherwise returns a list of the classes records.
 - table_name: sets the name of the temporary postgresql table. This can then be used in further instaload sql snippets.
 - relied_on: will make it so other instaload sql snippets can reference this table (it makes it use posrgresql's WITH operator)
@@ -349,7 +342,7 @@ User.instaload('SELECT id FROM users WHERE users.id = ANY (:user_ids) AND users.
 </details>
 
 #### self.dynamic_attach(instaload_sql_output, base_name, attach_name, base_on: nil, attach_on: nil, one_to_one: false)
-taking the output of the dynamic_instaload_sql, this method attaches the models together so they are attached.
+taking the output of the instaload_sql method, this method creates relations between the models.
 - base_name: the name of the table we will be attaching to
 - attach_name: the name of the table that will be attached
 - base_on: put a proc here to override the matching key for the base table. Default is, for a user and post type, {|user| user.id}
@@ -357,7 +350,7 @@ taking the output of the dynamic_instaload_sql, this method attaches the models
 - one_to_one: switches between a one-to-one relationship or not
 
 <details> 
-<summary> attach information for each limited_user in the dynamic_instaload_sql example </summary>
+<summary> attach information for each limited_user in the instaload_sql example </summary>
 	
 ```ruby
 	
@@ -456,13 +449,28 @@ since things may be broken already, it seemed like a good time to do this.
   - this also tells me that uniq'ing variables to decrease the number of them was a bad idea which could cause random failures.
 - functionality improvements
   - The biggest change is that names are now optional! name_modifiers is now depreciated functionality as it serves no useful purpose. Will leave in for compatibility but take out of documentation. Used to think the name was related to prepared statements. This will lead simpler ruby code.
-  - If name is left out, the name will be set to the location in your app which called the method. For example, when dynamic_sql was called from irb, the name was: "(irb):45:in `irb_binding'". This is done using stack trace functionality.
+  - If name is left out, the name will be set to the location in your app which called the method. For example, when dynamic_sql was called from irb, the name was: "(irb):45:in `irb_binding'". This is done using stack trace functionality. In another case the name was "app/models/report.rb:364:in `refresh_db_methods'"
   - dynamic_instaload_sql is now just instaload_sql. dynamic_instaload_sql has been aliased.
   - Name is optional on instaload_sql aswell
   - MultiAttributeArrays (array's of arrays) which can be passed into dynamic_sql largely for inserts/upserts will now treat symbols as an attribute name. This leads to more consise sql without running into above error.
   - When dynamic_sql errors out, it now posts some helpful information to the log.
   - Added a test script. No experience testing, so its just a method you pass a model, and then it does a rollback to reverse any changes.
-
+ 
+v3.0.6
+- Further simplifications of the library. After looking further into ActiveRecord::Response objects I realized that they respond to .map .first [3] and other Array methods. In addition to this they have the .rows and .cols methods. Feel like I should of caught this earlier, but anyway, functionaly i will be setting DYNAMIC_SQL_RAW to true by default. docs-wise I am removing any reference to the raw option and DYNAMIC_SQL_RAW. This is mainly as ActiveRecord::Response acts as an Array with more functionality.
+
+<<<<<<< HEAD
+3.0.11
+- error fix to do with multi row expressions and sql variables. No breaking changes.
+
+## Questions
+- Q: does the name of a sql operation have anything to do with prepared statements?
+- A: no, the prepared statement determines uniqueness in some other way, dont worry about collisions. The only issue with prepared statements that I can determine is when you write a statement where things change every time, thus preparing potentially infinite prepared statements. This can be alleviated by using sql arguments correctly. Using arguments correctly also will stop sql injection attacks so. You know. Do it properly. Dont just hard code them into the query.
+- Q: The default name of my sql statements looks like a stack trace? Whats going on?
+- A: We set the location of where you called the function as the default name for easy debugging. Its not an error, we just take some info from the stacktrace. It also includes the method name which can provide some insite into what the query is doing. Makes logs alot nicer to look at.
+- Q: Whats MeritFront?
+- A: I am making a social media platform
+	
 ## Contributing
 
 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).

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

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

data/lib/dynamic-records-meritfront.rb

@@ -1,6 +1,8 @@
 require "dynamic-records-meritfront/version"
 require 'hashid/rails'
 
+#this file contains multiple classes which should honestly be split up
+
 module DynamicRecordsMeritfront
 	extend ActiveSupport::Concern
 
@@ -17,7 +19,7 @@ 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 = false
+        DYNAMIC_SQL_RAW = true
 	end
     class DynamicSqlVariables
         attr_accessor :sql_hash
@@ -27,11 +29,17 @@ module DynamicRecordsMeritfront
             self.params = params
         end
 
+        def key_index(key)
+            k = sql_hash.keys.index(key)
+            k += 1 unless k.nil?
+            k
+        end
+
         def add_key_value(key, value = nil)
             value = params[key] if value.nil?
             #tracks the variable and returns the keys sql variable number
             sql_hash[key] ||= convert_to_query_attribute(key, value)
-            return sql_hash.keys.index(key) + 1
+            return key_index(key)
         end
 
         def next_sql_num
@@ -392,18 +400,27 @@ module DynamicRecordsMeritfront
                         #replace MultiRowExpressions
                         v = params[key]
                         #check if it looks like one
-                        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
+                        looks_like_multi_row_expression = ((v.class == Array) and (not v.first.nil?) and (v.first.class == Array))
+                        if v.class == MultiRowExpression or looks_like_multi_row_expression
                         #we need to substitute with the correct sql now.
-                            v = MultiRowExpression.new(v) if looks_like_multi_attribute_array #standardize
+                            v = MultiRowExpression.new(v) if looks_like_multi_row_expression #standardize
                             #process into appropriate sql while keeping track of variables
                             sql_for_replace = v.for_query(key, var_track)
                             #replace the key with the sql
                             sql.gsub!(":#{key}", sql_for_replace)
                         else
-                            x = var_track.next_sql_num
-                            if sql.gsub!(":#{key}", "$#{x}")
-                                var_track.add_key_value(key, v)
+                            #check if its currently in the sql argument list
+                            x = var_track.key_index(key)
+                            if x.nil?
+                                #if not, get the next number that it will be assigned and replace the key w/ that number.
+                                x = var_track.next_sql_num
+                                if sql.gsub!(":#{key}", "$#{x}")
+                                    #only actually add to sql arguments when we know the attribute was used.
+                                    var_track.add_key_value(key, v)
+                                end
+                            else
+                                #its already in use as a sql argument and has a number, use that number.
+                                sql.gsub!(":#{key}", "$#{x}")
                             end
                         end
                     end
@@ -437,12 +454,6 @@ module DynamicRecordsMeritfront
                 #no I am not actually this cool see https://stackoverflow.com/questions/30826015/convert-pgresult-to-an-active-record-model
                 ret = ret.to_a
                 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
@@ -593,6 +604,17 @@ module DynamicRecordsMeritfront
 				raise StandardError.new('Bad return') unless out["b"]
 				puts 'pass 7'
 
+                puts "test dynamic_sql V3.0.6 error to do with multi_attribute_arrays which is hard to describe"
+                time = DateTime.now
+                values = [[1, :time, :time], [2, :time, :time]]
+                out = ar.dynamic_sql(%Q{
+                    insert into #{mtname} (id, created_at, updated_at)
+                    values :values
+                    on conflict (id)
+                    do update set updated_at = :time
+                }, time: time, values: values)
+                puts 'pass 8'
+
 				raise ActiveRecord::Rollback
 				#ApplicationRecord.dynamic_sql("SELECT * FROM")
 			end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic-records-meritfront
 version: !ruby/object:Gem::Version
-  version: 3.0.3
+  version: 3.0.11
 platform: ruby
 authors:
 - Luke Clancy
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-12-12 00:00:00.000000000 Z
+date: 2023-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashid-rails
@@ -54,7 +54,7 @@ metadata:
   homepage_uri: https://github.com/LukeClancy/dynamic-records-meritfront
   source_code_uri: https://github.com/LukeClancy/dynamic-records-meritfront
   changelog_uri: https://github.com/LukeClancy/dynamic-records-meritfront/blob/main/README.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -69,8 +69,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Helpers for active record that allow for more abstract and fine-grained code.
 test_files: []