diff --git a/db/migrations/20240818230651_create_notes.cr b/db/migrations/20240818230651_create_notes.cr new file mode 100644 index 000000000..c6c003bf1 --- /dev/null +++ b/db/migrations/20240818230651_create_notes.cr @@ -0,0 +1,16 @@ +class CreateNotes::V20240818230651 < Avram::Migrator::Migration::V1 + def migrate + create table_for(Note) do + primary_key id : Int64 + add_timestamps + add from : String + add read : Bool, default: false + add text : String + add order : Int32, index: true + end + end + + def rollback + drop table_for(Note) + end +end diff --git a/spec/avram/bool_criteria_spec.cr b/spec/avram/bool_criteria_spec.cr index a73d4da93..dcd191fe4 100644 --- a/spec/avram/bool_criteria_spec.cr +++ b/spec/avram/bool_criteria_spec.cr @@ -1,7 +1,7 @@ require "../spec_helper" private class QueryMe < BaseModel - COLUMN_SQL = "users.id, users.created_at, users.updated_at, users.admin" + COLUMN_SQL = %("users"."id", "users"."created_at", "users"."updated_at", "users"."admin") table users do column admin : Bool @@ -11,8 +11,8 @@ end describe Bool::Lucky::Criteria do describe "is" do it "=" do - admin.eq(true).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.admin = $1", "true"] - admin.eq(false).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.admin = $1", "false"] + admin.eq(true).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."admin" = $1), "true"] + admin.eq(false).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."admin" = $1), "false"] end end end diff --git a/spec/avram/criteria_spec.cr b/spec/avram/criteria_spec.cr index 38827a9bb..4dd5fbdec 100644 --- a/spec/avram/criteria_spec.cr +++ b/spec/avram/criteria_spec.cr @@ -1,7 +1,7 @@ require "../spec_helper" private class QueryMe < BaseModel - COLUMN_SQL = "users.id, users.created_at, users.updated_at, users.age, users.nickname" + COLUMN_SQL = %("users"."id", "users"."created_at", "users"."updated_at", "users"."age", "users"."nickname") table users do column age : Int32 @@ -12,7 +12,7 @@ end describe Avram::Criteria do describe "eq" do it "uses =" do - age.eq(30).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age = $1", "30"] + age.eq(30).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" = $1), "30"] end end @@ -20,59 +20,59 @@ describe Avram::Criteria do it "uses =" do # Need to do this so that we get a nilable type nilable_age = 30.as(Int32?) - age.nilable_eq(nilable_age).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age = $1", "30"] + age.nilable_eq(nilable_age).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" = $1), "30"] end it "uses 'IS NULL' for comparisons to nil" do # Need to do this so that we get a nilable type, but not just Nil nilable = [nil, "name"].first - nickname.nilable_eq(nilable).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.nickname IS NULL"] + nickname.nilable_eq(nilable).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."nickname" IS NULL)] end end describe "is_nil" do it "uses IS NULL" do - nickname.is_nil.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.nickname IS NULL"] + nickname.is_nil.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."nickname" IS NULL)] end end describe "is_not_nil" do it "uses IS NOT NULL" do - nickname.is_not_nil.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.nickname IS NOT NULL"] + nickname.is_not_nil.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."nickname" IS NOT NULL)] end end describe "gt" do it "uses >" do - age.gt("30").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age > $1", "30"] + age.gt("30").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" > $1), "30"] end end describe "gte" do it "uses >=" do - age.gte("30").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age >= $1", "30"] + age.gte("30").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" >= $1), "30"] end end describe "lt" do it "uses <" do - age.lt("30").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age < $1", "30"] + age.lt("30").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" < $1), "30"] end end describe "lte" do it "uses <=" do - age.lte("30").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age <= $1", "30"] + age.lte("30").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" <= $1), "30"] end end describe "not" do it "negates the following criteria" do - age.not.gt("3").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age <= $1", "3"] + age.not.gt("3").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" <= $1), "3"] end it "resets after having negated once" do - age.not.gt("3").age.eq("20").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.age <= $1 AND users.age = $2", "3", "20"] + age.not.gt("3").age.eq("20").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."age" <= $1 AND "users"."age" = $2), "3", "20"] end end end diff --git a/spec/avram/float_criteria_spec.cr b/spec/avram/float_criteria_spec.cr index 9a2dc145f..902c6b615 100644 --- a/spec/avram/float_criteria_spec.cr +++ b/spec/avram/float_criteria_spec.cr @@ -1,7 +1,7 @@ require "../spec_helper" private class QueryMe < BaseModel - COLUMN_SQL = "purchases.id, purchases.created_at, purchases.updated_at, purchases.amount" + COLUMN_SQL = %("purchases"."id", "purchases"."created_at", "purchases"."updated_at", "purchases"."amount") table purchases do column amount : Float64 @@ -11,19 +11,19 @@ end describe Float64::Lucky::Criteria do describe "abs" do it "uses ABS" do - amount.abs.eq(39.99).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM purchases WHERE ABS(purchases.amount) = $1", "39.99"] + amount.abs.eq(39.99).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM purchases WHERE ABS(\"purchases\".\"amount\") = $1", "39.99"] end end describe "ceil" do it "uses CEIL" do - amount.ceil.eq(40.0).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM purchases WHERE CEIL(purchases.amount) = $1", "40.0"] + amount.ceil.eq(40.0).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM purchases WHERE CEIL(\"purchases\".\"amount\") = $1", "40.0"] end end describe "floor" do it "uses FLOOR" do - amount.floor.eq(39.0).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM purchases WHERE FLOOR(purchases.amount) = $1", "39.0"] + amount.floor.eq(39.0).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM purchases WHERE FLOOR(\"purchases\".\"amount\") = $1", "39.0"] end end end diff --git a/spec/avram/insert_spec.cr b/spec/avram/insert_spec.cr index c66501fcc..85507b3b6 100644 --- a/spec/avram/insert_spec.cr +++ b/spec/avram/insert_spec.cr @@ -5,14 +5,14 @@ describe Avram::Insert do it "inserts with a hash of String" do params = {:first_name => "Paul", :last_name => "Smith"} insert = Avram::Insert.new(table: :users, params: params) - insert.statement.should eq "insert into users(first_name, last_name) values($1, $2) returning *" + insert.statement.should eq %(insert into users("first_name", "last_name") values($1, $2) returning *) insert.args.should eq ["Paul", "Smith"] end it "inserts with a hash of Nil" do params = {:first_name => nil} insert = Avram::Insert.new(table: :users, params: params) - insert.statement.should eq "insert into users(first_name) values($1) returning *" + insert.statement.should eq %(insert into users("first_name") values($1) returning *) insert.args.should eq [nil] end end diff --git a/spec/avram/instrumentation_spec.cr b/spec/avram/instrumentation_spec.cr index bafcb1c78..88c22ebea 100644 --- a/spec/avram/instrumentation_spec.cr +++ b/spec/avram/instrumentation_spec.cr @@ -14,7 +14,7 @@ describe "Instrumentation" do UserQuery.new.name("Bob").first? event = Avram::Events::QueryEvent.logged_events.last - event.query.should contain("WHERE users.name = $1") + event.query.should contain(%(WHERE "users"."name" = $1)) event.args.to_s.should contain("Bob") event.queryable.should eq("User") end @@ -23,7 +23,7 @@ describe "Instrumentation" do UserQuery.new.name("Bob").select_count event = Avram::Events::QueryEvent.logged_events.last - event.query.should contain("WHERE users.name = $1") + event.query.should contain(%(WHERE "users"."name" = $1)) event.args.to_s.should contain("Bob") event.queryable.should eq("User") end diff --git a/spec/avram/integer_criteria_spec.cr b/spec/avram/integer_criteria_spec.cr index 27396c545..8286aa6b6 100644 --- a/spec/avram/integer_criteria_spec.cr +++ b/spec/avram/integer_criteria_spec.cr @@ -1,7 +1,7 @@ require "../spec_helper" private class QueryMe < BaseModel - COLUMN_SQL = "transactions.id, transactions.created_at, transactions.updated_at, transactions.small_amount, transactions.amount, transactions.big_amount" + COLUMN_SQL = %("transactions"."id", "transactions"."created_at", "transactions"."updated_at", "transactions"."small_amount", "transactions"."amount", "transactions"."big_amount") table transactions do column small_amount : Int16 @@ -14,9 +14,9 @@ end describe "Int::Lucky::Criteria" do describe "abs" do it "uses ABS" do - small_amount.abs.eq(4).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM transactions WHERE ABS(transactions.small_amount) = $1", "4"] - amount.abs.eq(400).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM transactions WHERE ABS(transactions.amount) = $1", "400"] - big_amount.abs.eq(40000).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM transactions WHERE ABS(transactions.big_amount) = $1", "40000"] + small_amount.abs.eq(4).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM transactions WHERE ABS(\"transactions\".\"small_amount\") = $1", "4"] + amount.abs.eq(400).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM transactions WHERE ABS(\"transactions\".\"amount\") = $1", "400"] + big_amount.abs.eq(40000).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM transactions WHERE ABS(\"transactions\".\"big_amount\") = $1", "40000"] end end end diff --git a/spec/avram/join_spec.cr b/spec/avram/join_spec.cr index 06d60f6a8..0bb438b16 100644 --- a/spec/avram/join_spec.cr +++ b/spec/avram/join_spec.cr @@ -3,43 +3,43 @@ require "../spec_helper" describe Avram::Join do describe "builds statements using defaults" do it "::INNER" do - Avram::Join::Inner.new(:users, :posts).to_sql.should eq "INNER JOIN posts ON users.id = posts.user_id" + Avram::Join::Inner.new(:users, :posts).to_sql.should eq %(INNER JOIN posts ON "users"."id" = "posts"."user_id") end it "::LEFT" do - Avram::Join::Left.new(:users, :posts).to_sql.should eq "LEFT JOIN posts ON users.id = posts.user_id" + Avram::Join::Left.new(:users, :posts).to_sql.should eq %(LEFT JOIN posts ON "users"."id" = "posts"."user_id") end it "::RIGHT" do - Avram::Join::Right.new(:users, :posts).to_sql.should eq "RIGHT JOIN posts ON users.id = posts.user_id" + Avram::Join::Right.new(:users, :posts).to_sql.should eq %(RIGHT JOIN posts ON "users"."id" = "posts"."user_id") end it "::FULL" do - Avram::Join::Full.new(:users, :posts).to_sql.should eq "FULL JOIN posts ON users.id = posts.user_id" + Avram::Join::Full.new(:users, :posts).to_sql.should eq %(FULL JOIN posts ON "users"."id" = "posts"."user_id") end end it "allows custom to and from columns" do Avram::Join::Inner.new(:users, :posts, primary_key: :uid, foreign_key: :author_id) .to_sql - .should eq "INNER JOIN posts ON users.uid = posts.author_id" + .should eq %(INNER JOIN posts ON "users"."uid" = "posts"."author_id") end it "allows different boolean comparisons" do Avram::Join::Inner.new(:users, :posts, comparison: "<@", foreign_key: :commenter_ids) .to_sql - .should eq "INNER JOIN posts ON users.id <@ posts.commenter_ids" + .should eq %(INNER JOIN posts ON "users"."id" <@ "posts"."commenter_ids") end it "allows joining using related columns" do Avram::Join::Inner.new(:employees, :managers, using: [:company_id, :department_id]) .to_sql - .should eq "INNER JOIN managers USING (company_id, department_id)" + .should eq %(INNER JOIN managers USING ("company_id", "department_id")) end it "allows aliasing the to table" do Avram::Join::Inner.new(from: :purchases, to: :users, alias_to: :sellers, primary_key: :seller_id, foreign_key: :id) .to_sql - .should eq "INNER JOIN users AS sellers ON purchases.seller_id = sellers.id" + .should eq %(INNER JOIN users AS sellers ON "purchases"."seller_id" = "sellers"."id") end end diff --git a/spec/avram/json_criteria_spec.cr b/spec/avram/json_criteria_spec.cr index b8fca7cbf..61aa19b49 100644 --- a/spec/avram/json_criteria_spec.cr +++ b/spec/avram/json_criteria_spec.cr @@ -1,7 +1,7 @@ require "../spec_helper" private class QueryMe < BaseModel - COLUMN_SQL = "users.id, users.created_at, users.updated_at, users.preferences" + COLUMN_SQL = %("users"."id", "users"."created_at", "users"."updated_at", "users"."preferences") table users do column preferences : JSON::Any @@ -11,31 +11,31 @@ end describe JSON::Any::Lucky::Criteria do describe "has_key" do it "?" do - preferences.has_key("theme").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.preferences ? $1", "theme"] + preferences.has_key("theme").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."preferences" ? $1), "theme"] end it "negates with NOT()" do - preferences.not.has_key("theme").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT(users.preferences ? $1)", "theme"] + preferences.not.has_key("theme").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT("users"."preferences" ? $1)), "theme"] end end describe "has_any_keys" do it "?|" do - preferences.has_any_keys(["theme", "style"]).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.preferences ?| $1", ["theme", "style"]] + preferences.has_any_keys(["theme", "style"]).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."preferences" ?| $1), ["theme", "style"]] end it "negates with NOT()" do - preferences.not.has_any_keys(["theme", "style"]).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT(users.preferences ?| $1)", ["theme", "style"]] + preferences.not.has_any_keys(["theme", "style"]).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT("users"."preferences" ?| $1)), ["theme", "style"]] end end describe "has_all_keys" do it "?&" do - preferences.has_all_keys(["theme", "style"]).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.preferences ?& $1", ["theme", "style"]] + preferences.has_all_keys(["theme", "style"]).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."preferences" ?& $1), ["theme", "style"]] end it "negates with NOT()" do - preferences.not.has_all_keys(["theme", "style"]).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT(users.preferences ?& $1)", ["theme", "style"]] + preferences.not.has_all_keys(["theme", "style"]).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT("users"."preferences" ?& $1)), ["theme", "style"]] end end @@ -43,13 +43,13 @@ describe JSON::Any::Lucky::Criteria do it "@>" do json = JSON::Any.new({"theme" => JSON::Any.new("dark")}) critera = preferences.includes(json) - critera.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.preferences @> $1", "{\"theme\":\"dark\"}"] + critera.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."preferences" @> $1), %({"theme":"dark"})] end it "negates with NOT()" do json = JSON::Any.new({"theme" => JSON::Any.new("dark")}) critera = preferences.not.includes(json) - critera.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT(users.preferences @> $1)", "{\"theme\":\"dark\"}"] + critera.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT("users"."preferences" @> $1)), %({"theme":"dark"})] end end @@ -57,13 +57,13 @@ describe JSON::Any::Lucky::Criteria do it "<@" do json = JSON::Any.new({"theme" => JSON::Any.new("dark"), "style" => JSON::Any.new("cyberpunk"), "version" => JSON::Any.new(2i64)}) critera = preferences.in(json) - critera.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.preferences <@ $1", "{\"theme\":\"dark\",\"style\":\"cyberpunk\",\"version\":2}"] + critera.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."preferences" <@ $1), %({"theme":"dark","style":"cyberpunk","version":2})] end it "negates with NOT()" do json = JSON::Any.new({"theme" => JSON::Any.new("dark"), "style" => JSON::Any.new("cyberpunk"), "version" => JSON::Any.new(2i64)}) critera = preferences.not.in(json) - critera.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT(users.preferences <@ $1)", "{\"theme\":\"dark\",\"style\":\"cyberpunk\",\"version\":2}"] + critera.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE NOT("users"."preferences" <@ $1)), %({"theme":"dark","style":"cyberpunk","version":2})] end end end diff --git a/spec/avram/migrator/alter_table_statement_spec.cr b/spec/avram/migrator/alter_table_statement_spec.cr index 3862fcc9d..f5d84aeb6 100644 --- a/spec/avram/migrator/alter_table_statement_spec.cr +++ b/spec/avram/migrator/alter_table_statement_spec.cr @@ -29,25 +29,25 @@ describe Avram::Migrator::AlterTableStatement do built.statements[2].should eq <<-SQL ALTER TABLE users - ADD name text, - ADD email text, - ADD nickname text NOT NULL, - ADD age int4 NOT NULL DEFAULT '1', - ADD num bigint NOT NULL DEFAULT '1', - ADD amount_paid decimal(10,5) NOT NULL DEFAULT '1.0', - ADD completed boolean NOT NULL DEFAULT 'false', - ADD meta jsonb NOT NULL DEFAULT '{"default":"value"}', - ADD joined_at timestamptz NOT NULL DEFAULT NOW(), - ADD updated_at timestamptz, - ADD future_time timestamptz NOT NULL DEFAULT '#{Time.local.to_utc}', - ADD new_id uuid NOT NULL DEFAULT '46d9b2f0-0718-4d4c-a5a1-5af81d5b11e0', - ADD numbers int4[], + ADD "name" text, + ADD "email" text, + ADD "nickname" text NOT NULL, + ADD "age" int4 NOT NULL DEFAULT '1', + ADD "num" bigint NOT NULL DEFAULT '1', + ADD "amount_paid" decimal(10,5) NOT NULL DEFAULT '1.0', + ADD "completed" boolean NOT NULL DEFAULT 'false', + ADD "meta" jsonb NOT NULL DEFAULT '{"default":"value"}', + ADD "joined_at" timestamptz NOT NULL DEFAULT NOW(), + ADD "updated_at" timestamptz, + ADD "future_time" timestamptz NOT NULL DEFAULT '#{Time.local.to_utc}', + ADD "new_id" uuid NOT NULL DEFAULT '46d9b2f0-0718-4d4c-a5a1-5af81d5b11e0', + ADD "numbers" int4[], DROP old_column, DROP employee_id; SQL - built.statements[3].should eq "CREATE UNIQUE INDEX users_age_index ON users USING btree (age);" - built.statements[4].should eq "CREATE INDEX users_num_index ON users USING btree (num);" + built.statements[3].should eq %(CREATE UNIQUE INDEX users_age_index ON users USING btree ("age");) + built.statements[4].should eq %(CREATE INDEX users_num_index ON users USING btree ("num");) built.statements[5].should eq "UPDATE users SET email = 'noreply@lucky.com';" built.statements[6].should eq "ALTER TABLE users ALTER COLUMN email SET NOT NULL;" built.statements[7].should eq "UPDATE users SET updated_at = NOW();" @@ -117,7 +117,7 @@ describe Avram::Migrator::AlterTableStatement do end built.statements.size.should eq 3 - built.statements[0].should eq "ALTER TABLE users\n ADD confirmed_at timestamptz;" + built.statements[0].should eq %(ALTER TABLE users\n ADD "confirmed_at" timestamptz;) built.statements[1].should eq "UPDATE users SET confirmed_at = NOW();" built.statements[2].should eq "ALTER TABLE users ALTER COLUMN confirmed_at SET NOT NULL;" end @@ -128,7 +128,7 @@ describe Avram::Migrator::AlterTableStatement do end built.statements.size.should eq 2 - built.statements[0].should eq "ALTER TABLE users\n ADD confirmed_at timestamptz;" + built.statements[0].should eq %(ALTER TABLE users\n ADD "confirmed_at" timestamptz;) built.statements[1].should eq "UPDATE users SET confirmed_at = NOW();" end @@ -138,7 +138,7 @@ describe Avram::Migrator::AlterTableStatement do end built.statements.size.should eq 3 - built.statements[0].should eq "ALTER TABLE users\n ADD admin boolean;" + built.statements[0].should eq %(ALTER TABLE users\n ADD "admin" boolean;) built.statements[1].should eq "UPDATE users SET admin = 'false';" built.statements[2].should eq "ALTER TABLE users ALTER COLUMN admin SET NOT NULL;" end @@ -157,20 +157,20 @@ describe Avram::Migrator::AlterTableStatement do built.statements.first.should eq <<-SQL ALTER TABLE comments - ADD user_id bigint NOT NULL REFERENCES users ON DELETE CASCADE, - ADD post_id bigint REFERENCES posts ON DELETE RESTRICT, - ADD category_label_id bigint NOT NULL REFERENCES custom_table ON DELETE SET NULL, - ADD employee_id bigint NOT NULL REFERENCES users ON DELETE CASCADE, - ADD line_item_id uuid NOT NULL REFERENCES line_items ON DELETE CASCADE, - ADD subscription_item_id bigint NOT NULL REFERENCES subscription_items ON DELETE CASCADE; + ADD "user_id" bigint NOT NULL REFERENCES users ON DELETE CASCADE, + ADD "post_id" bigint REFERENCES posts ON DELETE RESTRICT, + ADD "category_label_id" bigint NOT NULL REFERENCES custom_table ON DELETE SET NULL, + ADD "employee_id" bigint NOT NULL REFERENCES users ON DELETE CASCADE, + ADD "line_item_id" uuid NOT NULL REFERENCES line_items ON DELETE CASCADE, + ADD "subscription_item_id" bigint NOT NULL REFERENCES subscription_items ON DELETE CASCADE; SQL - built.statements[1].should eq "CREATE UNIQUE INDEX comments_user_id_index ON comments USING btree (user_id);" - built.statements[2].should eq "CREATE INDEX comments_post_id_index ON comments USING btree (post_id);" - built.statements[3].should eq "CREATE INDEX comments_category_label_id_index ON comments USING btree (category_label_id);" - built.statements[4].should eq "CREATE INDEX comments_employee_id_index ON comments USING btree (employee_id);" - built.statements[5].should eq "CREATE INDEX comments_line_item_id_index ON comments USING btree (line_item_id);" - built.statements[6].should eq "CREATE INDEX comments_subscription_item_id_index ON comments USING btree (subscription_item_id);" + built.statements[1].should eq %(CREATE UNIQUE INDEX comments_user_id_index ON comments USING btree ("user_id");) + built.statements[2].should eq %(CREATE INDEX comments_post_id_index ON comments USING btree ("post_id");) + built.statements[3].should eq %(CREATE INDEX comments_category_label_id_index ON comments USING btree ("category_label_id");) + built.statements[4].should eq %(CREATE INDEX comments_employee_id_index ON comments USING btree ("employee_id");) + built.statements[5].should eq %(CREATE INDEX comments_line_item_id_index ON comments USING btree ("line_item_id");) + built.statements[6].should eq %(CREATE INDEX comments_subscription_item_id_index ON comments USING btree ("subscription_item_id");) built.statements[7].should eq "UPDATE comments SET line_item_id = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11';" end @@ -189,8 +189,8 @@ describe Avram::Migrator::AlterTableStatement do end built.statements.size.should eq 4 - built.statements[0].should eq "ALTER TABLE comments\n ADD line_item_id uuid NOT NULL REFERENCES line_items ON DELETE CASCADE;" - built.statements[1].should eq "CREATE INDEX comments_line_item_id_index ON comments USING btree (line_item_id);" + built.statements[0].should eq %(ALTER TABLE comments\n ADD "line_item_id" uuid NOT NULL REFERENCES line_items ON DELETE CASCADE;) + built.statements[1].should eq %(CREATE INDEX comments_line_item_id_index ON comments USING btree ("line_item_id");) built.statements[2].should eq "UPDATE comments SET line_item_id = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11';" built.statements[3].should eq "ALTER TABLE comments ALTER COLUMN line_item_id SET NOT NULL;" end @@ -201,8 +201,8 @@ describe Avram::Migrator::AlterTableStatement do end built.statements.size.should eq 3 - built.statements[0].should eq "ALTER TABLE comments\n ADD line_item_id uuid REFERENCES line_items ON DELETE CASCADE;" - built.statements[1].should eq "CREATE INDEX comments_line_item_id_index ON comments USING btree (line_item_id);" + built.statements[0].should eq %(ALTER TABLE comments\n ADD "line_item_id" uuid REFERENCES line_items ON DELETE CASCADE;) + built.statements[1].should eq %(CREATE INDEX comments_line_item_id_index ON comments USING btree ("line_item_id");) built.statements[2].should eq "UPDATE comments SET line_item_id = 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11';" end end @@ -213,7 +213,7 @@ describe Avram::Migrator::AlterTableStatement do add_belongs_to guest : User?, on_delete: :cascade, fill_existing_with: :nothing end - built.statements[1].should eq "CREATE INDEX challenges_guest_id_index ON challenges USING btree (guest_id);" + built.statements[1].should eq %(CREATE INDEX challenges_guest_id_index ON challenges USING btree ("guest_id");) built.statements.size.should eq(2) end end @@ -233,7 +233,7 @@ describe Avram::Migrator::AlterTableStatement do built.statements[2].should eq <<-SQL ALTER TABLE IF EXISTS users - ADD name text; + ADD "name" text; SQL end end diff --git a/spec/avram/migrator/create_index_statement_spec.cr b/spec/avram/migrator/create_index_statement_spec.cr index a0f77046f..a759a31c7 100644 --- a/spec/avram/migrator/create_index_statement_spec.cr +++ b/spec/avram/migrator/create_index_statement_spec.cr @@ -3,35 +3,35 @@ require "../../spec_helper" describe Avram::Migrator::CreateIndexStatement do it "generates correct CREATE INDEX sql" do statement = Avram::Migrator::CreateIndexStatement.new(:users, :email).build - statement.should eq "CREATE INDEX users_email_index ON users USING btree (email);" + statement.should eq %(CREATE INDEX users_email_index ON users USING btree ("email");) statement = Avram::Migrator::CreateIndexStatement.new(:users, columns: :email, using: :btree, unique: true).build - statement.should eq "CREATE UNIQUE INDEX users_email_index ON users USING btree (email);" + statement.should eq %(CREATE UNIQUE INDEX users_email_index ON users USING btree ("email");) end it "supports other index types" do statement = Avram::Migrator::CreateIndexStatement.new(:users, columns: :tags, using: :hash).build - statement.should eq "CREATE INDEX users_tags_index ON users USING hash (tags);" + statement.should eq %(CREATE INDEX users_tags_index ON users USING hash ("tags");) statement = Avram::Migrator::CreateIndexStatement.new(:users, columns: :tags, using: :gist).build - statement.should eq "CREATE INDEX users_tags_index ON users USING gist (tags);" + statement.should eq %(CREATE INDEX users_tags_index ON users USING gist ("tags");) statement = Avram::Migrator::CreateIndexStatement.new(:users, columns: :tags, using: :gin).build - statement.should eq "CREATE INDEX users_tags_index ON users USING gin (tags);" + statement.should eq %(CREATE INDEX users_tags_index ON users USING gin ("tags");) statement = Avram::Migrator::CreateIndexStatement.new(:users, columns: :tags, using: :brin).build - statement.should eq "CREATE INDEX users_tags_index ON users USING brin (tags);" + statement.should eq %(CREATE INDEX users_tags_index ON users USING brin ("tags");) end it "generates correct multi-column index sql" do statement = Avram::Migrator::CreateIndexStatement.new(:users, columns: [:email, :username], using: :btree, unique: true).build - statement.should eq "CREATE UNIQUE INDEX users_email_username_index ON users USING btree (email, username);" + statement.should eq %(CREATE UNIQUE INDEX users_email_username_index ON users USING btree ("email", "username");) end context "custom index name" do it "generates correct CREATE INDEX sql with given name" do statement = Avram::Migrator::CreateIndexStatement.new(:users, :email, name: :custom_index_name).build - statement.should eq "CREATE INDEX custom_index_name ON users USING btree (email);" + statement.should eq %(CREATE INDEX custom_index_name ON users USING btree ("email");) end end end diff --git a/spec/avram/migrator/create_table_statement_spec.cr b/spec/avram/migrator/create_table_statement_spec.cr index 0e032dbf3..f433eaebb 100644 --- a/spec/avram/migrator/create_table_statement_spec.cr +++ b/spec/avram/migrator/create_table_statement_spec.cr @@ -28,17 +28,17 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 1 built.statements.first.should eq <<-SQL CREATE TABLE users ( - id serial4 PRIMARY KEY, - created_at timestamptz NOT NULL DEFAULT NOW(), - updated_at timestamptz NOT NULL DEFAULT NOW(), - name text NOT NULL, - age int4 NOT NULL, - completed boolean NOT NULL, - joined_at timestamptz NOT NULL, - amount_paid decimal(10,2) NOT NULL, - email text, - meta jsonb, - reference uuid NOT NULL); + "id" serial4 PRIMARY KEY, + "created_at" timestamptz NOT NULL DEFAULT NOW(), + "updated_at" timestamptz NOT NULL DEFAULT NOW(), + "name" text NOT NULL, + "age" int4 NOT NULL, + "completed" boolean NOT NULL, + "joined_at" timestamptz NOT NULL, + "amount_paid" decimal(10,2) NOT NULL, + "email" text, + "meta" jsonb, + "reference" uuid NOT NULL); SQL end @@ -50,7 +50,7 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 1 built.statements.first.should eq <<-SQL CREATE TABLE users ( - id uuid PRIMARY KEY DEFAULT gen_random_uuid()); + "id" uuid PRIMARY KEY DEFAULT gen_random_uuid()); SQL built = Avram::Migrator::CreateTableStatement.new(:users).build do @@ -60,7 +60,7 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 1 built.statements.first.should eq <<-SQL CREATE TABLE users ( - custom_id_name bigserial PRIMARY KEY); + "custom_id_name" bigserial PRIMARY KEY); SQL built = Avram::Migrator::CreateTableStatement.new(:users).build do @@ -70,7 +70,7 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 1 built.statements.first.should eq <<-SQL CREATE TABLE users ( - id smallserial PRIMARY KEY); + "id" smallserial PRIMARY KEY); SQL end @@ -84,9 +84,9 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 1 built.statements.first.should eq <<-SQL CREATE TABLE users ( - id1 bigint NOT NULL, - id2 uuid NOT NULL, - PRIMARY KEY (id1, id2)); + "id1" bigint NOT NULL, + "id2" uuid NOT NULL, + PRIMARY KEY ("id1", "id2")); SQL end @@ -102,10 +102,10 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 1 built.statements.first.should eq <<-SQL CREATE TABLE users ( - id1 bigint NOT NULL, - id2 uuid NOT NULL, - example text NOT NULL, - PRIMARY KEY (id1, id2)); + "id1" bigint NOT NULL, + "id2" uuid NOT NULL, + "example" text NOT NULL, + PRIMARY KEY ("id1", "id2")); SQL end @@ -128,18 +128,18 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 1 built.statements.first.should eq <<-SQL CREATE TABLE users ( - name text NOT NULL DEFAULT 'name', - email text DEFAULT 'optional', - age int4 NOT NULL DEFAULT '1', - num bigint NOT NULL DEFAULT '1', - amount_paid decimal NOT NULL DEFAULT '1.0', - completed boolean NOT NULL DEFAULT 'false', - meta jsonb NOT NULL DEFAULT '{}', - joined_at timestamptz NOT NULL DEFAULT NOW(), - future_time timestamptz NOT NULL DEFAULT '#{Time.local.to_utc}', - friend_count smallint NOT NULL DEFAULT '1', - friends text[] NOT NULL DEFAULT '{"Paul"}', - problems text[] NOT NULL DEFAULT '{}'); + "name" text NOT NULL DEFAULT 'name', + "email" text DEFAULT 'optional', + "age" int4 NOT NULL DEFAULT '1', + "num" bigint NOT NULL DEFAULT '1', + "amount_paid" decimal NOT NULL DEFAULT '1.0', + "completed" boolean NOT NULL DEFAULT 'false', + "meta" jsonb NOT NULL DEFAULT '{}', + "joined_at" timestamptz NOT NULL DEFAULT NOW(), + "future_time" timestamptz NOT NULL DEFAULT '#{Time.local.to_utc}', + "friend_count" smallint NOT NULL DEFAULT '1', + "friends" text[] NOT NULL DEFAULT '{"Paul"}', + "problems" text[] NOT NULL DEFAULT '{}'); SQL end @@ -156,13 +156,13 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 4 built.statements.first.should eq <<-SQL CREATE TABLE users ( - name text NOT NULL, - age int4 NOT NULL, - email text NOT NULL); + "name" text NOT NULL, + "age" int4 NOT NULL, + "email" text NOT NULL); SQL - built.statements[1].should eq "CREATE INDEX users_name_index ON users USING btree (name);" - built.statements[2].should eq "CREATE UNIQUE INDEX users_age_index ON users USING btree (age);" - built.statements[3].should eq "CREATE UNIQUE INDEX users_email_index ON users USING btree (email);" + built.statements[1].should eq %(CREATE INDEX users_name_index ON users USING btree ("name");) + built.statements[2].should eq %(CREATE UNIQUE INDEX users_age_index ON users USING btree ("age");) + built.statements[3].should eq %(CREATE UNIQUE INDEX users_email_index ON users USING btree ("email");) end it "raises error on columns with non allowed index types" do @@ -196,20 +196,20 @@ describe Avram::Migrator::CreateTableStatement do built.statements.first.should eq <<-SQL CREATE TABLE comments ( - user_id bigint NOT NULL REFERENCES users ON DELETE CASCADE, - post_id bigint REFERENCES posts ON DELETE RESTRICT, - category_label_id bigint NOT NULL REFERENCES custom_table ON DELETE SET NULL, - employee_id bigint NOT NULL REFERENCES users ON DELETE CASCADE, - line_item_id uuid NOT NULL REFERENCES line_items ON DELETE CASCADE, - subscription_item_id bigint NOT NULL REFERENCES subscription_items ON DELETE CASCADE); + "user_id" bigint NOT NULL REFERENCES users ON DELETE CASCADE, + "post_id" bigint REFERENCES posts ON DELETE RESTRICT, + "category_label_id" bigint NOT NULL REFERENCES custom_table ON DELETE SET NULL, + "employee_id" bigint NOT NULL REFERENCES users ON DELETE CASCADE, + "line_item_id" uuid NOT NULL REFERENCES line_items ON DELETE CASCADE, + "subscription_item_id" bigint NOT NULL REFERENCES subscription_items ON DELETE CASCADE); SQL - built.statements[1].should eq "CREATE INDEX comments_user_id_index ON comments USING btree (user_id);" - built.statements[2].should eq "CREATE INDEX comments_post_id_index ON comments USING btree (post_id);" - built.statements[3].should eq "CREATE INDEX comments_category_label_id_index ON comments USING btree (category_label_id);" - built.statements[4].should eq "CREATE INDEX comments_employee_id_index ON comments USING btree (employee_id);" - built.statements[5].should eq "CREATE INDEX comments_line_item_id_index ON comments USING btree (line_item_id);" - built.statements[6].should eq "CREATE INDEX comments_subscription_item_id_index ON comments USING btree (subscription_item_id);" + built.statements[1].should eq %(CREATE INDEX comments_user_id_index ON comments USING btree ("user_id");) + built.statements[2].should eq %(CREATE INDEX comments_post_id_index ON comments USING btree ("post_id");) + built.statements[3].should eq %(CREATE INDEX comments_category_label_id_index ON comments USING btree ("category_label_id");) + built.statements[4].should eq %(CREATE INDEX comments_employee_id_index ON comments USING btree ("employee_id");) + built.statements[5].should eq %(CREATE INDEX comments_line_item_id_index ON comments USING btree ("line_item_id");) + built.statements[6].should eq %(CREATE INDEX comments_subscription_item_id_index ON comments USING btree ("subscription_item_id");) end it "can create tables with association on composite primary keys" do @@ -222,9 +222,9 @@ describe Avram::Migrator::CreateTableStatement do built.statements.size.should eq 2 built.statements.first.should eq <<-SQL CREATE TABLE comments ( - user_id bigint NOT NULL REFERENCES users ON DELETE CASCADE, - id2 bigint NOT NULL, - PRIMARY KEY (user_id, id2)); + "user_id" bigint NOT NULL REFERENCES users ON DELETE CASCADE, + "id2" bigint NOT NULL, + PRIMARY KEY ("user_id", "id2")); SQL end @@ -242,7 +242,7 @@ describe Avram::Migrator::CreateTableStatement do add_belongs_to guest : User, on_delete: :cascade end - built.statements[1].should eq "CREATE INDEX challenges_guest_id_index ON challenges USING btree (guest_id);" + built.statements[1].should eq %(CREATE INDEX challenges_guest_id_index ON challenges USING btree ("guest_id");) built.statements.size.should eq(2) end end diff --git a/spec/avram/model_spec.cr b/spec/avram/model_spec.cr index 04a858cc1..8fa9a8cc2 100644 --- a/spec/avram/model_spec.cr +++ b/spec/avram/model_spec.cr @@ -8,7 +8,7 @@ class NamedSpaced::Model < BaseModel end private class QueryMe < BaseModel - COLUMN_SQL = "users.id, users.created_at, users.updated_at, users.email, users.age" + COLUMN_SQL = %("users"."id", "users"."created_at", "users"."updated_at", "users"."email", "users"."age") table :users do column email : CustomEmail @@ -22,7 +22,7 @@ private class EmptyModelCompilesOk < BaseModel end private class InferredTableNameModel < BaseModel - COLUMN_SQL = "inferred_table_name_models.id, inferred_table_name_models.created_at, inferred_table_name_models.updated_at" + COLUMN_SQL = %("inferred_table_name_models"."id", "inferred_table_name_models"."created_at", "inferred_table_name_models"."updated_at") table do end @@ -91,6 +91,19 @@ describe Avram::Model do user.email.to_s.should eq "foo@bar.com" end + it "allows columns named the same as reserved SQL names" do + NoteFactory.create(&.from("Me").text("hi").read(true).order(4)) + note = NoteQuery.new.from("Me").first + note.from.should eq("Me") + note.text.should eq("hi") + note.read?.should eq(true) + Note::SaveOperation.update!(note, read: false) + note = note.reload + note.read?.should eq(false) + Note::DeleteOperation.delete!(note) + NoteQuery.new.select_count.should eq(0) + end + describe "reload" do it "can reload a model" do user = UserFactory.create &.name("Original Name") @@ -118,25 +131,25 @@ describe Avram::Model do it "sets up simple methods for equality" do query = QueryMe::BaseQuery.new.email("foo@bar.com").age(30) - query.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.email = $1 AND users.age = $2", "foo@bar.com", "30"] + query.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."email" = $1 AND "users"."age" = $2), "foo@bar.com", "30"] end it "sets up advanced criteria methods" do query = QueryMe::BaseQuery.new.email.upper.eq("foo@bar.com").age.gt(30) - query.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE UPPER(users.email) = $1 AND users.age > $2", "foo@bar.com", "30"] + query.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE UPPER("users"."email") = $1 AND "users"."age" > $2), "foo@bar.com", "30"] end it "parses values" do query = QueryMe::BaseQuery.new.email.upper.eq(" Foo@bar.com").age.gt(30) - query.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE UPPER(users.email) = $1 AND users.age > $2", "foo@bar.com", "30"] + query.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE UPPER("users"."email") = $1 AND "users"."age" > $2), "foo@bar.com", "30"] end it "lets you order by columns" do query = QueryMe::BaseQuery.new.age.asc_order.email.desc_order - query.to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users ORDER BY users.age ASC, users.email DESC"] + query.to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users ORDER BY "users"."age" ASC, "users"."email" DESC)] end it "can be deleted" do diff --git a/spec/avram/query_builder/merge_spec.cr b/spec/avram/query_builder/merge_spec.cr index c6ef4dbd4..c04d8de56 100644 --- a/spec/avram/query_builder/merge_spec.cr +++ b/spec/avram/query_builder/merge_spec.cr @@ -13,7 +13,7 @@ describe "Avram::QueryBuilder#merge" do query_1.merge(query_2) - query_1.statement.should eq "SELECT * FROM users INNER JOIN posts ON users.id = posts.user_id INNER JOIN tasks ON users.id = tasks.user_id WHERE age = $1 AND name = 'Mary' AND age = $2 AND name = 'Greg'" + query_1.statement.should eq %(SELECT * FROM users INNER JOIN posts ON "users"."id" = "posts"."user_id" INNER JOIN tasks ON "users"."id" = "tasks"."user_id" WHERE age = $1 AND name = 'Mary' AND age = $2 AND name = 'Greg') query_1.args.should eq ["42", "20"] end diff --git a/spec/avram/query_builder_spec.cr b/spec/avram/query_builder_spec.cr index a9ae98a72..1afbe5877 100644 --- a/spec/avram/query_builder_spec.cr +++ b/spec/avram/query_builder_spec.cr @@ -9,7 +9,7 @@ describe Avram::QueryBuilder do .order_by(Avram::OrderBy.new(:my_column, :asc)) query.joins.size.should eq(1) - query.statement.should eq "SELECT * FROM users INNER JOIN posts ON users.id = posts.user_id ORDER BY my_column ASC" + query.statement.should eq %(SELECT * FROM users INNER JOIN posts ON "users"."id" = "posts"."user_id" ORDER BY my_column ASC) end it "does not remove potentially duplicate where clauses" do @@ -239,7 +239,7 @@ describe Avram::QueryBuilder do it "specifies columns to be selected" do query = new_query.select([:name, :age]) - query.statement.should eq "SELECT users.name, users.age FROM users" + query.statement.should eq %(SELECT "users"."name", "users"."age" FROM users) end end @@ -248,7 +248,7 @@ describe Avram::QueryBuilder do .join(Avram::Join::Inner.new(:users, :posts)) .limit(1) - query.statement.should eq "SELECT * FROM users INNER JOIN posts ON users.id = posts.user_id LIMIT 1" + query.statement.should eq %(SELECT * FROM users INNER JOIN posts ON "users"."id" = "posts"."user_id" LIMIT 1) end describe "#reverse_order" do @@ -310,9 +310,9 @@ describe Avram::QueryBuilder do .limit(10) .offset(5) - cloned_query.statement.should eq "SELECT users.name, users.age FROM users INNER JOIN posts ON users.id = posts.user_id WHERE name = $1 AND age > $2 ORDER BY id ASC LIMIT 10 OFFSET 5" + cloned_query.statement.should eq %(SELECT "users"."name", "users"."age" FROM users INNER JOIN posts ON "users"."id" = "posts"."user_id" WHERE name = $1 AND age > $2 ORDER BY id ASC LIMIT 10 OFFSET 5) - old_query.statement.should eq "SELECT users.name, users.age FROM users INNER JOIN posts ON users.id = posts.user_id WHERE name = $1 ORDER BY id ASC LIMIT 1 OFFSET 2" + old_query.statement.should eq %(SELECT "users"."name", "users"."age" FROM users INNER JOIN posts ON "users"."id" = "posts"."user_id" WHERE name = $1 ORDER BY id ASC LIMIT 1 OFFSET 2) end end diff --git a/spec/avram/query_logging_spec.cr b/spec/avram/query_logging_spec.cr index 93ca144af..968335d0a 100644 --- a/spec/avram/query_logging_spec.cr +++ b/spec/avram/query_logging_spec.cr @@ -4,7 +4,7 @@ describe "Query logging" do it "logs the statement and args" do Avram::QueryLog.dexter.temp_config do |log_io| UserQuery.new.name("Bob").first? - log_io.to_s.should contain %(WHERE users.name = $1) + log_io.to_s.should contain %(WHERE \\"users\\".\\"name\\" = $1) log_io.to_s.should contain %(Bob) log_io.to_s.should contain %(duration) end diff --git a/spec/avram/queryable_spec.cr b/spec/avram/queryable_spec.cr index 37a725526..3faa38704 100644 --- a/spec/avram/queryable_spec.cr +++ b/spec/avram/queryable_spec.cr @@ -53,13 +53,13 @@ describe Avram::Queryable do it "can set default queries" do query = QueryWithDefault.new.query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE users.age >= $1" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."age" >= $1) end it "allows you to add on to a query with default" do query = QueryWithDefault.new.name("Santa").query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE users.age >= $1 AND users.name = $2" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."age" >= $1 AND "users"."name" = $2) end it "releases connection if no open transaction", tags: Avram::SpecHelper::TRUNCATE do @@ -108,7 +108,7 @@ describe Avram::Queryable do it "resets where on a specific column" do query = UserQuery.new.name("Purcell").age(35).reset_where(&.name).query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE users.age = $1" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."age" = $1) query.args.should eq ["35"] of String end @@ -131,7 +131,7 @@ describe Avram::Queryable do queryable = UserQuery.new.distinct_on(&.name).order_by(:name, :asc).order_by(:age, :asc) query = queryable.query - query.statement.should eq "SELECT DISTINCT ON (users.name) #{User::COLUMN_SQL} FROM users ORDER BY name ASC, age ASC" + query.statement.should eq %(SELECT DISTINCT ON ("users"."name") #{User::COLUMN_SQL} FROM users ORDER BY name ASC, age ASC) query.args.should eq [] of String results = queryable.results first = results.first @@ -207,7 +207,7 @@ describe Avram::Queryable do user.should_not be_nil user.as(User).name.should eq "First" - user_query.should eq "SELECT #{User::COLUMN_SQL} FROM users ORDER BY users.id ASC LIMIT 1" + user_query.should eq %(SELECT #{User::COLUMN_SQL} FROM users ORDER BY "users"."id" ASC LIMIT 1) end it "returns nil if no record found" do @@ -299,7 +299,7 @@ describe Avram::Queryable do user.should_not be_nil user.as(User).name.should eq "Last" - user_query.should eq "SELECT #{User::COLUMN_SQL} FROM users ORDER BY users.id DESC LIMIT 1" + user_query.should eq %(SELECT #{User::COLUMN_SQL} FROM users ORDER BY "users"."id" DESC LIMIT 1) end it "returns nil if last record is not found" do @@ -462,14 +462,14 @@ describe Avram::Queryable do it "chains ors" do query = UserQuery.new.age(26).or(&.age(32)).or(&.age(59)).query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE users.age = $1 OR users.age = $2 OR users.age = $3" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."age" = $1 OR "users"."age" = $2 OR "users"."age" = $3) query.args.should eq ["26", "32", "59"] end it "nests AND conjunctions inside of OR blocks" do query = UserQuery.new.age(26).or(&.age(32).name("Pat")).or(&.age(59)).query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE users.age = $1 OR users.age = $2 AND users.name = $3 OR users.age = $4" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."age" = $1 OR "users"."age" = $2 AND "users"."name" = $3 OR "users"."age" = $4) query.args.should eq ["26", "32", "Pat", "59"] end end @@ -478,7 +478,7 @@ describe Avram::Queryable do it "wraps a simple where clause with parenthesis" do query = UserQuery.new.where(&.age(30)).query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE ( users.age = $1 )" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE ( "users"."age" = $1 )) query.args.should eq ["30"] end @@ -493,7 +493,7 @@ describe Avram::Queryable do q.nickname("Strange") }.query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE ( ( users.age = $1 OR users.age = $2 ) AND ( users.name = $3 OR users.name = $4 ) ) OR users.nickname = $5" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE ( ( "users"."age" = $1 OR "users"."age" = $2 ) AND ( "users"."name" = $3 OR "users"."name" = $4 ) ) OR "users"."nickname" = $5) query.args.should eq ["25", "26", "Billy", "Tommy", "Strange"] end @@ -503,7 +503,7 @@ describe Avram::Queryable do new_query = orig_query.where(&.nickname("BusyCat")).limit(3) orig_query.query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users" - new_query.query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE ( users.nickname = $1 ) LIMIT 3" + new_query.query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE ( "users"."nickname" = $1 ) LIMIT 3) end it "doesn't add parenthesis when query to wrap is provided" do @@ -516,7 +516,7 @@ describe Avram::Queryable do end end.age(25).query - query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users WHERE users.name = $1 AND users.age = $2" + query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."name" = $1 AND "users"."age" = $2) query.args.should eq ["Susan", "25"] end end @@ -533,7 +533,7 @@ describe Avram::Queryable do UserFactory.create users = UserQuery.new.name.desc_order.limit(1) - users.query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users ORDER BY users.name DESC LIMIT 1" + users.query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users ORDER BY "users"."name" DESC LIMIT 1) users.results.size.should eq(1) end @@ -1061,7 +1061,7 @@ describe Avram::Queryable do CommentFactory.new.post_id(post.id).create query = Comment::BaseQuery.new.join_post - query.to_sql.should eq ["SELECT comments.custom_id, comments.created_at, comments.updated_at, comments.body, comments.post_id FROM comments INNER JOIN posts ON comments.post_id = posts.custom_id"] + query.to_sql.should eq [%(SELECT #{Comment::COLUMN_SQL} FROM comments INNER JOIN posts ON "comments"."post_id" = "posts"."custom_id")] result = query.first result.post.should eq post @@ -1081,7 +1081,7 @@ describe Avram::Queryable do comment = CommentFactory.new.post_id(post.id).create query = Post::BaseQuery.new.join_comments - query.to_sql.should eq ["SELECT posts.custom_id, posts.created_at, posts.updated_at, posts.title, posts.published_at FROM posts INNER JOIN comments ON posts.custom_id = comments.post_id"] + query.to_sql.should eq [%(SELECT #{Post::COLUMN_SQL} FROM posts INNER JOIN comments ON "posts"."custom_id" = "comments"."post_id")] result = query.first result.comments.first.should eq comment @@ -1102,7 +1102,7 @@ describe Avram::Queryable do TaggingFactory.new.post_id(post.id).tag_id(tag.id).create query = Post::BaseQuery.new.join_tags - query.to_sql.should eq ["SELECT posts.custom_id, posts.created_at, posts.updated_at, posts.title, posts.published_at FROM posts INNER JOIN taggings ON posts.custom_id = taggings.post_id INNER JOIN tags ON taggings.tag_id = tags.custom_id"] + query.to_sql.should eq [%(SELECT #{Post::COLUMN_SQL} FROM posts INNER JOIN taggings ON "posts"."custom_id" = "taggings"."post_id" INNER JOIN tags ON "taggings"."tag_id" = "tags"."custom_id")] result = query.first result.tags.first.should eq tag @@ -1123,7 +1123,7 @@ describe Avram::Queryable do employee = EmployeeFactory.create query = Employee::BaseQuery.new.left_join_manager - query.to_sql.should eq ["SELECT employees.id, employees.created_at, employees.updated_at, employees.name, employees.manager_id FROM employees LEFT JOIN managers ON employees.manager_id = managers.id"] + query.to_sql.should eq [%(SELECT #{Employee::COLUMN_SQL} FROM employees LEFT JOIN managers ON "employees"."manager_id" = "managers"."id")] result = query.first result.should eq employee @@ -1142,7 +1142,7 @@ describe Avram::Queryable do post = PostFactory.create query = Post::BaseQuery.new.left_join_comments - query.to_sql.should eq ["SELECT posts.custom_id, posts.created_at, posts.updated_at, posts.title, posts.published_at FROM posts LEFT JOIN comments ON posts.custom_id = comments.post_id"] + query.to_sql.should eq [%(SELECT #{Post::COLUMN_SQL} FROM posts LEFT JOIN comments ON "posts"."custom_id" = "comments"."post_id")] result = query.first result.should eq post @@ -1161,7 +1161,7 @@ describe Avram::Queryable do post = PostFactory.create query = Post::BaseQuery.new.left_join_tags - query.to_sql.should eq ["SELECT posts.custom_id, posts.created_at, posts.updated_at, posts.title, posts.published_at FROM posts LEFT JOIN taggings ON posts.custom_id = taggings.post_id LEFT JOIN tags ON taggings.tag_id = tags.custom_id"] + query.to_sql.should eq [%(SELECT #{Post::COLUMN_SQL} FROM posts LEFT JOIN taggings ON "posts"."custom_id" = "taggings"."post_id" LEFT JOIN tags ON "taggings"."tag_id" = "tags"."custom_id")] result = query.first result.should eq post @@ -1183,17 +1183,17 @@ describe Avram::Queryable do blob = BlobFactory.new.doc(JSON::Any.new({"foo" => JSON::Any.new("bar")})).create query = JSONQuery.new.static_foo - query.to_sql.should eq ["SELECT blobs.id, blobs.created_at, blobs.updated_at, blobs.doc, blobs.metadata, blobs.media, blobs.servers FROM blobs WHERE blobs.doc = $1", "{\"foo\":\"bar\"}"] + query.to_sql.should eq [%(SELECT #{Blob::COLUMN_SQL} FROM blobs WHERE "blobs"."doc" = $1), %({"foo":"bar"})] result = query.first result.should eq blob query2 = JSONQuery.new.foo_with_value("bar") - query2.to_sql.should eq ["SELECT blobs.id, blobs.created_at, blobs.updated_at, blobs.doc, blobs.metadata, blobs.media, blobs.servers FROM blobs WHERE blobs.doc = $1", "{\"foo\":\"bar\"}"] + query2.to_sql.should eq [%(SELECT #{Blob::COLUMN_SQL} FROM blobs WHERE "blobs"."doc" = $1), %({"foo":"bar"})] result = query2.first result.should eq blob query3 = JSONQuery.new.foo_with_value("baz") - query3.to_sql.should eq ["SELECT blobs.id, blobs.created_at, blobs.updated_at, blobs.doc, blobs.metadata, blobs.media, blobs.servers FROM blobs WHERE blobs.doc = $1", "{\"foo\":\"baz\"}"] + query3.to_sql.should eq [%(SELECT #{Blob::COLUMN_SQL} FROM blobs WHERE "blobs"."doc" = $1), %({"foo":"baz"})] expect_raises(Avram::RecordNotFoundError) do query3.first end @@ -1207,7 +1207,7 @@ describe Avram::Queryable do bucket = BucketFactory.new.names(["pumpkin", "zucchini"]).enums([Bucket::Size::Medium]).create query = BucketQuery.new.names(["pumpkin", "zucchini"]) - query.to_sql.should eq ["SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE buckets.names = $1", "{\"pumpkin\",\"zucchini\"}"] + query.to_sql.should eq [%(SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE "buckets"."names" = $1), %({"pumpkin","zucchini"})] result = query.first result.should eq bucket @@ -1222,7 +1222,7 @@ describe Avram::Queryable do query = BucketQuery.new.numbers.includes(13) - query.to_sql.should eq ["SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE $1 = ANY (buckets.numbers)", "13"] + query.to_sql.should eq [%(SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE $1 = ANY ("buckets"."numbers")), "13"] query.select_count.should eq(1) query.first.id.should eq(bucket1.id) end @@ -1233,7 +1233,7 @@ describe Avram::Queryable do query = BucketQuery.new.numbers.not.includes(13) - query.to_sql.should eq ["SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE $1 != ALL (buckets.numbers)", "13"] + query.to_sql.should eq [%(SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE $1 != ALL ("buckets"."numbers")), "13"] query.select_count.should eq(1) query.first.id.should eq(bucket2.id) end @@ -1246,7 +1246,7 @@ describe Avram::Queryable do business = BusinessFactory.new.create query = BusinessQuery.new.name(business.name) - query.to_sql.should eq ["SELECT #{Business::COLUMN_SQL} FROM businesses WHERE businesses.name = $1", business.name] + query.to_sql.should eq [%(SELECT #{Business::COLUMN_SQL} FROM businesses WHERE "businesses"."name" = $1), business.name] result = query.first result.should eq business end @@ -1401,19 +1401,19 @@ describe Avram::Queryable do describe "#asc_order" do it "orders by a joined table" do query = Post::BaseQuery.new.where_comments(Comment::BaseQuery.new.created_at.asc_order) - query.to_sql[0].should contain "ORDER BY comments.created_at ASC" + query.to_sql[0].should contain %(ORDER BY "comments"."created_at" ASC) end it "orders nulls first" do query = Post::BaseQuery.new.published_at.asc_order(:nulls_first) - query.to_sql[0].should contain "ORDER BY posts.published_at ASC NULLS FIRST" + query.to_sql[0].should contain %(ORDER BY "posts"."published_at" ASC NULLS FIRST) end it "orders nulls last" do query = Post::BaseQuery.new.published_at.asc_order(:nulls_last) - query.to_sql[0].should contain "ORDER BY posts.published_at ASC NULLS LAST" + query.to_sql[0].should contain %(ORDER BY "posts"."published_at" ASC NULLS LAST) end it "doesn't mutate the query" do @@ -1428,7 +1428,7 @@ describe Avram::Queryable do it "resets random order clauses" do query = Post::BaseQuery.new.random_order.published_at.asc_order - query.to_sql[0].should contain "ORDER BY posts.published_at ASC" + query.to_sql[0].should contain %(ORDER BY "posts"."published_at" ASC) query.to_sql[0].should_not contain "RANDOM ()" end end @@ -1443,7 +1443,7 @@ describe Avram::Queryable do it "resets previous order clauses" do query = Post::BaseQuery.new.published_at.desc_order.random_order - query.to_sql[0].should_not contain "posts.published_at DESC" + query.to_sql[0].should_not contain %("posts"."published_at" DESC) query.to_sql[0].should contain "ORDER BY RANDOM ()" end end @@ -1455,7 +1455,7 @@ describe Avram::Queryable do original_query.to_sql.size.should eq 2 new_query.to_sql.size.should eq 3 - new_query.to_sql[0].should contain "ORDER BY users.joined_at" + new_query.to_sql[0].should contain %(ORDER BY "users"."joined_at") original_query.to_sql[0].should_not contain "ORDER BY" end @@ -1524,7 +1524,7 @@ describe Avram::Queryable do post = PostFactory.create &.published_at(3.days.ago) posts = Post::BaseQuery.new.published_at.between(start_date, end_date) - posts.query.statement.should eq "SELECT posts.custom_id, posts.created_at, posts.updated_at, posts.title, posts.published_at FROM posts WHERE posts.published_at >= $1 AND posts.published_at <= $2" + posts.query.statement.should eq %(SELECT #{Post::COLUMN_SQL} FROM posts WHERE "posts"."published_at" >= $1 AND "posts"."published_at" <= $2) posts.query.args.should eq [start_date.to_s("%Y-%m-%d %H:%M:%S.%6N %z"), end_date.to_s("%Y-%m-%d %H:%M:%S.%6N %z")] posts.first.should eq post end @@ -1533,7 +1533,7 @@ describe Avram::Queryable do company = CompanyFactory.create &.sales(50) companies = Company::BaseQuery.new.sales.between(1, 100) - companies.query.statement.should eq "SELECT companies.id, companies.created_at, companies.updated_at, companies.sales, companies.earnings FROM companies WHERE companies.sales >= $1 AND companies.sales <= $2" + companies.query.statement.should eq %(SELECT #{Company::COLUMN_SQL} FROM companies WHERE "companies"."sales" >= $1 AND "companies"."sales" <= $2) companies.query.args.should eq ["1", "100"] companies.first.should eq company end @@ -1542,7 +1542,7 @@ describe Avram::Queryable do company = CompanyFactory.create &.earnings(300.45) companies = Company::BaseQuery.new.earnings.between(123.45, 678.901) - companies.query.statement.should eq "SELECT companies.id, companies.created_at, companies.updated_at, companies.sales, companies.earnings FROM companies WHERE companies.earnings >= $1 AND companies.earnings <= $2" + companies.query.statement.should eq %(SELECT #{Company::COLUMN_SQL} FROM companies WHERE "companies"."earnings" >= $1 AND "companies"."earnings" <= $2) companies.query.args.should eq ["123.45", "678.901"] companies.first.should eq company end @@ -1564,7 +1564,7 @@ describe Avram::Queryable do UserFactory.create &.age(21).name("Jim") users = UserQuery.new.group(&.age).group(&.id) - users.query.statement.should eq "SELECT #{User::COLUMN_SQL} FROM users GROUP BY users.age, users.id" + users.query.statement.should eq %(SELECT #{User::COLUMN_SQL} FROM users GROUP BY "users"."age", "users"."id") users.map(&.name).sort!.should eq ["Dwight", "Jim", "Michael"] end @@ -1611,16 +1611,16 @@ describe Avram::Queryable do describe "#to_prepared_sql" do it "returns the full SQL with args combined" do query = Post::BaseQuery.new.title("The Short Post") - query.to_prepared_sql.should eq(%{SELECT posts.custom_id, posts.created_at, posts.updated_at, posts.title, posts.published_at FROM posts WHERE posts.title = 'The Short Post'}) + query.to_prepared_sql.should eq(%{SELECT #{Post::COLUMN_SQL} FROM posts WHERE "posts"."title" = 'The Short Post'}) query = Bucket::BaseQuery.new.names(["Larry", "Moe", "Curly"]).numbers([1, 2, 3]) - query.to_prepared_sql.should eq(%{SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE buckets.names = '{"Larry","Moe","Curly"}' AND buckets.numbers = '{1,2,3}'}) + query.to_prepared_sql.should eq(%{SELECT #{Bucket::COLUMN_SQL} FROM buckets WHERE "buckets"."names" = '{"Larry","Moe","Curly"}' AND "buckets"."numbers" = '{1,2,3}'}) query = Blob::BaseQuery.new.doc(JSON::Any.new({"properties" => JSON::Any.new("sold")})) - query.to_prepared_sql.should eq(%{SELECT blobs.id, blobs.created_at, blobs.updated_at, blobs.doc, blobs.metadata, blobs.media, blobs.servers FROM blobs WHERE blobs.doc = '{"properties":"sold"}'}) + query.to_prepared_sql.should eq(%{SELECT #{Blob::COLUMN_SQL} FROM blobs WHERE "blobs"."doc" = '{"properties":"sold"}'}) query = UserQuery.new.name.in(["Don", "Juan"]).age.gt(30) - query.to_prepared_sql.should eq(%{SELECT #{User::COLUMN_SQL} FROM users WHERE users.name = ANY ('{"Don","Juan"}') AND users.age > '30'}) + query.to_prepared_sql.should eq(%{SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."name" = ANY ('{"Don","Juan"}') AND "users"."age" > '30'}) end it "returns the full SQL with a lot of args" do @@ -1641,7 +1641,7 @@ describe Avram::Queryable do .available_for_hire(true) .created_at(a_day) - query.to_prepared_sql.should eq(%{SELECT users.id, users.created_at, users.updated_at, users.name, users.age, users.year_born, users.nickname, users.joined_at, users.total_score, users.average_score, users.available_for_hire FROM users WHERE users.name = 'Don' AND users.age > '21' AND users.age < '99' AND users.nickname ILIKE 'j%' AND users.nickname ILIKE '%y' AND users.joined_at > '#{a_week.to_s("%F %X.%6N %z")}' AND users.joined_at < '#{an_hour.to_s("%F %X.%6N %z")}' AND users.average_score > '1.2' AND users.average_score < '4.9' AND users.available_for_hire = 'true' AND users.created_at = '#{a_day.to_s("%F %X.%6N %z")}'}) + query.to_prepared_sql.should eq(%{SELECT #{User::COLUMN_SQL} FROM users WHERE "users"."name" = 'Don' AND "users"."age" > '21' AND "users"."age" < '99' AND "users"."nickname" ILIKE 'j%' AND "users"."nickname" ILIKE '%y' AND "users"."joined_at" > '#{a_week.to_s("%F %X.%6N %z")}' AND "users"."joined_at" < '#{an_hour.to_s("%F %X.%6N %z")}' AND "users"."average_score" > '1.2' AND "users"."average_score" < '4.9' AND "users"."available_for_hire" = 'true' AND "users"."created_at" = '#{a_day.to_s("%F %X.%6N %z")}'}) end end diff --git a/spec/avram/string_criteria_spec.cr b/spec/avram/string_criteria_spec.cr index a79705a81..ad6fdfa28 100644 --- a/spec/avram/string_criteria_spec.cr +++ b/spec/avram/string_criteria_spec.cr @@ -1,7 +1,7 @@ require "../spec_helper" private class QueryMe < BaseModel - COLUMN_SQL = "users.id, users.created_at, users.updated_at, users.name" + COLUMN_SQL = %("users"."id", "users"."created_at", "users"."updated_at", "users"."name") table users do column name : String @@ -11,63 +11,63 @@ end describe String::Lucky::Criteria do describe "like" do it "uses LIKE" do - name.like("elon").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.name LIKE $1", "elon"] + name.like("elon").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."name" LIKE $1), "elon"] end end describe "ilike" do it "uses LIKE" do - name.ilike("elon").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.name ILIKE $1", "elon"] + name.ilike("elon").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."name" ILIKE $1), "elon"] end end describe "lower" do it "uses LOWER" do - name.lower.eq("elon").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE LOWER(users.name) = $1", "elon"] + name.lower.eq("elon").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE LOWER("users"."name") = $1), "elon"] end end describe "upper" do it "uses UPPER" do - name.upper.eq("elon").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE UPPER(users.name) = $1", "elon"] + name.upper.eq("elon").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE UPPER("users"."name") = $1), "elon"] end end describe "trim" do it "uses TRIM" do - name.trim.eq("elon").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE TRIM(users.name) = $1", "elon"] + name.trim.eq("elon").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE TRIM("users"."name") = $1), "elon"] end end describe "not" do describe "with chained criteria" do it "negates the following criteria" do - name.not.like("pete").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.name NOT LIKE $1", "pete"] - name.not.ilike("pete").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.name NOT ILIKE $1", "pete"] + name.not.like("pete").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."name" NOT LIKE $1), "pete"] + name.not.ilike("pete").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."name" NOT ILIKE $1), "pete"] end it "resets after having negated once" do - name.not.like("pete").name.eq("sarah").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.name NOT LIKE $1 AND users.name = $2", "pete", "sarah"] - name.not.ilike("pete").name.eq("sarah").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE users.name NOT ILIKE $1 AND users.name = $2", "pete", "sarah"] + name.not.like("pete").name.eq("sarah").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."name" NOT LIKE $1 AND "users"."name" = $2), "pete", "sarah"] + name.not.ilike("pete").name.eq("sarah").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."name" NOT ILIKE $1 AND "users"."name" = $2), "pete", "sarah"] end end end describe "length" do it "uses LENGTH" do - name.length.eq(4).to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE LENGTH(users.name) = $1", "4"] + name.length.eq(4).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE LENGTH("users"."name") = $1), "4"] end end describe "reverse" do it "uses REVERSE" do - name.reverse.eq("revir").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE REVERSE(users.name) = $1", "revir"] + name.reverse.eq("revir").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE REVERSE("users"."name") = $1), "revir"] end end describe "match" do it "uses @@" do - name.to_tsvector.match("jeb").to_sql.should eq ["SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE TO_TSVECTOR(users.name) @@ TO_TSQUERY($1)", "jeb"] + name.to_tsvector.match("jeb").to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE TO_TSVECTOR("users"."name") @@ TO_TSQUERY($1)), "jeb"] end end end diff --git a/spec/avram/time_criteria_spec.cr b/spec/avram/time_criteria_spec.cr index 13074e1e0..a8995ca43 100644 --- a/spec/avram/time_criteria_spec.cr +++ b/spec/avram/time_criteria_spec.cr @@ -1,6 +1,7 @@ require "../spec_helper" private class QueryMe < BaseModel + COLUMN_SQL = %("users"."id", "users"."created_at", "users"."updated_at", "users"."activated_at") table users do column activated_at : Time end @@ -10,13 +11,13 @@ describe Time::Lucky::Criteria do describe "is" do it "=" do now = Time.utc - activated_at.eq(now).to_sql.should eq ["SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE users.activated_at = $1", now.to_s("%F %X.%6N %z")] + activated_at.eq(now).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE "users"."activated_at" = $1), now.to_s("%F %X.%6N %z")] end end it "as_date" do input_date = "2012-01-31" - activated_at.as_date.eq(input_date).to_sql.should eq ["SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE DATE(users.activated_at) = $1", input_date] + activated_at.as_date.eq(input_date).to_sql.should eq [%(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE DATE("users"."activated_at") = $1), input_date] end describe "extract" do @@ -26,126 +27,126 @@ describe Time::Lucky::Criteria do describe "returning integer" do it "century" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(century from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(century from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Century).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:century).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_century.eq(5).to_sql.should eq [output_query, "5"] end it "day" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(day from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(day from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Day).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:day).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_day.eq(5).to_sql.should eq [output_query, "5"] end it "decade" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(decade from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(decade from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Decade).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:decade).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_decade.eq(5).to_sql.should eq [output_query, "5"] end it "dow" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(dow from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(dow from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Dow).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:dow).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_dow.eq(5).to_sql.should eq [output_query, "5"] end it "doy" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(doy from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(doy from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Doy).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:doy).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_doy.eq(5).to_sql.should eq [output_query, "5"] end it "hour" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(hour from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(hour from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Hour).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:hour).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_hour.eq(5).to_sql.should eq [output_query, "5"] end it "isodow" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(isodow from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(isodow from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Isodow).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:isodow).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_isodow.eq(5).to_sql.should eq [output_query, "5"] end it "isoyear" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(isoyear from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(isoyear from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Isoyear).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:isoyear).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_isoyear.eq(5).to_sql.should eq [output_query, "5"] end it "microseconds" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(microseconds from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(microseconds from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Microseconds).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:microseconds).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_microseconds.eq(5).to_sql.should eq [output_query, "5"] end it "millennium" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(millennium from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(millennium from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Millennium).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:millennium).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_millennium.eq(5).to_sql.should eq [output_query, "5"] end it "minute" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(minute from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(minute from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Minute).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:minute).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_minute.eq(5).to_sql.should eq [output_query, "5"] end it "month" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(month from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(month from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Month).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:month).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_month.eq(5).to_sql.should eq [output_query, "5"] end it "quarter" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(quarter from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(quarter from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Quarter).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:quarter).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_quarter.eq(5).to_sql.should eq [output_query, "5"] end it "timezone" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(timezone from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(timezone from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Timezone).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:timezone).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_timezone.eq(5).to_sql.should eq [output_query, "5"] end it "timezone_hour" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(timezone_hour from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(timezone_hour from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::TimezoneHour).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:timezone_hour).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_timezone_hour.eq(5).to_sql.should eq [output_query, "5"] end it "timezone_minute" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(timezone_minute from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(timezone_minute from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::TimezoneMinute).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:timezone_minute).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_timezone_minute.eq(5).to_sql.should eq [output_query, "5"] end it "week" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(week from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(week from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Week).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:week).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_week.eq(5).to_sql.should eq [output_query, "5"] end it "year" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(year from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(year from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Year).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract(:year).eq(5).to_sql.should eq [output_query, "5"] activated_at.extract_year.eq(5).to_sql.should eq [output_query, "5"] @@ -154,28 +155,28 @@ describe Time::Lucky::Criteria do describe "returning float" do it "epoch" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(epoch from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(epoch from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Epoch).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract(:epoch).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract_epoch.eq(5).to_sql.should eq [output_query, "5.0"] end it "julian" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(julian from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(julian from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Julian).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract(:julian).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract_julian.eq(5).to_sql.should eq [output_query, "5.0"] end it "milliseconds" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(milliseconds from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(milliseconds from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Milliseconds).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract(:milliseconds).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract_milliseconds.eq(5).to_sql.should eq [output_query, "5.0"] end it "second" do - output_query = "SELECT users.id, users.created_at, users.updated_at, users.activated_at FROM users WHERE extract(second from users.activated_at) = $1" + output_query = %(SELECT #{QueryMe::COLUMN_SQL} FROM users WHERE extract(second from "users"."activated_at") = $1) activated_at.extract(Avram::ChronoUnits::Second).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract(:second).eq(5).to_sql.should eq [output_query, "5.0"] activated_at.extract_second.eq(5).to_sql.should eq [output_query, "5.0"] diff --git a/spec/support/factories/note_factory.cr b/spec/support/factories/note_factory.cr new file mode 100644 index 000000000..58d0a33ac --- /dev/null +++ b/spec/support/factories/note_factory.cr @@ -0,0 +1,4 @@ +class NoteFactory < BaseFactory + def initialize + end +end diff --git a/spec/support/models/admin.cr b/spec/support/models/admin.cr index 987ca4fe3..dc617528c 100644 --- a/spec/support/models/admin.cr +++ b/spec/support/models/admin.cr @@ -1,5 +1,5 @@ class Admin < BaseModel - COLUMN_SQL = "admins.id, admins.created_at, admins.updated_at, admins.name" + COLUMN_SQL = %("admins"."id", "admins"."created_at", "admins"."updated_at", "admins"."name") table do column name : String diff --git a/spec/support/models/article.cr b/spec/support/models/article.cr index 06a390a75..fdf867489 100644 --- a/spec/support/models/article.cr +++ b/spec/support/models/article.cr @@ -1,5 +1,5 @@ class Article < BaseModel - COLUMN_SQL = "articles.id, articles.created_at, articles.updated_at, articles.title, articles.slug" + COLUMN_SQL = %("articles"."id", "articles"."created_at", "articles"."updated_at", "articles"."title", "articles"."slug") table do column title : String diff --git a/spec/support/models/beat.cr b/spec/support/models/beat.cr index 401bdb846..4a71b35be 100644 --- a/spec/support/models/beat.cr +++ b/spec/support/models/beat.cr @@ -1,5 +1,5 @@ class Beat < BaseModel - COLUMN_SQL = "beats.id, beats.created_at, beats.updated_at, beats.hash" + COLUMN_SQL = %("beats"."id", "beats"."created_at", "beats"."updated_at", "beats"."hash") table do column hash : Bytes diff --git a/spec/support/models/blob.cr b/spec/support/models/blob.cr index 9f2c963af..662bbf1b0 100644 --- a/spec/support/models/blob.cr +++ b/spec/support/models/blob.cr @@ -17,6 +17,7 @@ class ServerMetadata end class Blob < BaseModel + COLUMN_SQL = %("blobs"."id", "blobs"."created_at", "blobs"."updated_at", "blobs"."doc", "blobs"."metadata", "blobs"."media", "blobs"."servers") table do column doc : JSON::Any? column metadata : BlobMetadata, serialize: true diff --git a/spec/support/models/bucket.cr b/spec/support/models/bucket.cr index 31dddafc9..c17406cec 100644 --- a/spec/support/models/bucket.cr +++ b/spec/support/models/bucket.cr @@ -1,5 +1,5 @@ class Bucket < BaseModel - COLUMN_SQL = column_names.join(", ") { |col| "buckets.#{col}" } + COLUMN_SQL = column_names.join(", ") { |col| %("buckets"."#{col}") } enum Size ExtraSmall diff --git a/spec/support/models/business.cr b/spec/support/models/business.cr index d1f3500e7..5148479fa 100644 --- a/spec/support/models/business.cr +++ b/spec/support/models/business.cr @@ -1,5 +1,5 @@ class Business < BaseModel - COLUMN_SQL = "businesses.id, businesses.created_at, businesses.updated_at, businesses.name, businesses.latitude, businesses.longitude" + COLUMN_SQL = %("businesses"."id", "businesses"."created_at", "businesses"."updated_at", "businesses"."name", "businesses"."latitude", "businesses"."longitude") table do column name : String diff --git a/spec/support/models/comment.cr b/spec/support/models/comment.cr index 66934fb07..945a218dc 100644 --- a/spec/support/models/comment.cr +++ b/spec/support/models/comment.cr @@ -1,4 +1,5 @@ class Comment < BaseModel + COLUMN_SQL = %("comments"."custom_id", "comments"."created_at", "comments"."updated_at", "comments"."body", "comments"."post_id") skip_default_columns table do diff --git a/spec/support/models/company.cr b/spec/support/models/company.cr index cde21453d..360706b2d 100644 --- a/spec/support/models/company.cr +++ b/spec/support/models/company.cr @@ -1,4 +1,5 @@ class Company < BaseModel + COLUMN_SQL = %("companies"."id", "companies"."created_at", "companies"."updated_at", "companies"."sales", "companies"."earnings") table do column sales : Int64 = 0_i64 column earnings : Float64 = 0.0 diff --git a/spec/support/models/employee.cr b/spec/support/models/employee.cr index 8230f35ee..3a75f0504 100644 --- a/spec/support/models/employee.cr +++ b/spec/support/models/employee.cr @@ -1,4 +1,5 @@ class Employee < BaseModel + COLUMN_SQL = %("employees"."id", "employees"."created_at", "employees"."updated_at", "employees"."name", "employees"."manager_id") table do column name : String belongs_to manager : Manager? diff --git a/spec/support/models/issue.cr b/spec/support/models/issue.cr index 739472b0f..43933b417 100644 --- a/spec/support/models/issue.cr +++ b/spec/support/models/issue.cr @@ -1,5 +1,5 @@ class Issue < BaseModel - COLUMN_SQL = "issues.id, issues.status, issues.role" + COLUMN_SQL = %("issues"."id", "issues"."status", "issues"."role") enum Status Opened diff --git a/spec/support/models/note.cr b/spec/support/models/note.cr new file mode 100644 index 000000000..6a9b297fc --- /dev/null +++ b/spec/support/models/note.cr @@ -0,0 +1,11 @@ +class Note < BaseModel + table do + column from : String + column read : Bool = false + column text : String + column order : Int32 + end +end + +class NoteQuery < Note::BaseQuery +end diff --git a/spec/support/models/post.cr b/spec/support/models/post.cr index 2afa7cd04..c873f30c6 100644 --- a/spec/support/models/post.cr +++ b/spec/support/models/post.cr @@ -1,4 +1,5 @@ class Post < BaseModel + COLUMN_SQL = %("posts"."custom_id", "posts"."created_at", "posts"."updated_at", "posts"."title", "posts"."published_at") skip_default_columns table do diff --git a/spec/support/models/user.cr b/spec/support/models/user.cr index a2ce6f1c9..f04d10cae 100644 --- a/spec/support/models/user.cr +++ b/spec/support/models/user.cr @@ -1,5 +1,5 @@ class User < BaseModel - COLUMN_SQL = "users.id, users.created_at, users.updated_at, users.name, users.age, users.year_born, users.nickname, users.joined_at, users.total_score, users.average_score, users.available_for_hire" + COLUMN_SQL = %("users"."id", "users"."created_at", "users"."updated_at", "users"."name", "users"."age", "users"."year_born", "users"."nickname", "users"."joined_at", "users"."total_score", "users"."average_score", "users"."available_for_hire") table do column name : String diff --git a/src/avram/base_query_template.cr b/src/avram/base_query_template.cr index ace778178..5269f5a5c 100644 --- a/src/avram/base_query_template.cr +++ b/src/avram/base_query_template.cr @@ -10,7 +10,7 @@ class Avram::BaseQueryTemplate macro generate_criteria_method(name, type) def \{{ name }} - \{{ type }}.adapter.criteria(self, "#{table_name}.\{{ name }}") + \{{ type }}.adapter.criteria(self, %("#{table_name}"."\{{ name }}")) end end diff --git a/src/avram/insert.cr b/src/avram/insert.cr index fd218b16a..a8d01d1da 100644 --- a/src/avram/insert.cr +++ b/src/avram/insert.cr @@ -12,7 +12,7 @@ class Avram::Insert if @column_names.empty? "*" else - @column_names.join(", ") { |column| "#{@table}.#{column}" } + @column_names.join(", ") { |column| %("#{@table}"."#{column}") } end end @@ -21,7 +21,7 @@ class Avram::Insert end private def fields : String - @params.keys.join(", ") + @params.keys.join(", ") { |col| %("#{col}") } end private def values_placeholders : String diff --git a/src/avram/join.cr b/src/avram/join.cr index a3b566bc0..d27410239 100644 --- a/src/avram/join.cr +++ b/src/avram/join.cr @@ -4,15 +4,18 @@ module Avram::Join abstract class SqlClause getter from : TableName + @using : String + def initialize( @from : TableName, @to : TableName, @primary_key : Symbol? = nil, @foreign_key : Symbol? = nil, @comparison : String? = "=", - @using : Array(Symbol) = [] of Symbol, + using : Array(Symbol) = [] of Symbol, @alias_to : TableName? = nil ) + @using = using.join(", ") { |col| %("#{col}") } end abstract def join_type : String @@ -24,8 +27,8 @@ module Avram::Join if @alias_to io << " AS #{@alias_to}" end - if !@using.empty? - io << " USING (#{@using.join(", ")})" + if @using.presence + io << " USING (#{@using})" else io << " ON #{from_column} #{@comparison} #{to_column}" end @@ -37,11 +40,11 @@ module Avram::Join end def from_column : String - "#{@from}.#{@primary_key || "id"}" + %("#{@from}"."#{@primary_key || "id"}") end def to_column : String - "#{to}.#{@foreign_key || default_foreign_key}" + %("#{to}"."#{@foreign_key || default_foreign_key}") end def default_foreign_key : String diff --git a/src/avram/migrator/columns/base.cr b/src/avram/migrator/columns/base.cr index 8a9ae16b7..badeae8d3 100644 --- a/src/avram/migrator/columns/base.cr +++ b/src/avram/migrator/columns/base.cr @@ -52,7 +52,7 @@ abstract class Avram::Migrator::Columns::Base private def build_add_statement : String String.build do |row| - row << name.to_s + row << %("#{name}") row << " " row << column_type + as_array_type row << null_fragment diff --git a/src/avram/migrator/columns/primary_keys/base.cr b/src/avram/migrator/columns/primary_keys/base.cr index 7fc0d8369..13fe6e258 100644 --- a/src/avram/migrator/columns/primary_keys/base.cr +++ b/src/avram/migrator/columns/primary_keys/base.cr @@ -6,6 +6,6 @@ abstract class Avram::Migrator::Columns::PrimaryKeys::Base abstract def column_type def build : String - %( #{name} #{column_type} PRIMARY KEY) + %( "#{name}" #{column_type} PRIMARY KEY) end end diff --git a/src/avram/migrator/columns/primary_keys/uuid_primary_key.cr b/src/avram/migrator/columns/primary_keys/uuid_primary_key.cr index abfe318af..55aa06f4d 100644 --- a/src/avram/migrator/columns/primary_keys/uuid_primary_key.cr +++ b/src/avram/migrator/columns/primary_keys/uuid_primary_key.cr @@ -10,7 +10,7 @@ module Avram::Migrator::Columns::PrimaryKeys end def build : String - %( #{name} #{column_type} PRIMARY KEY DEFAULT gen_random_uuid()) + %( "#{name}" #{column_type} PRIMARY KEY DEFAULT gen_random_uuid()) end end end diff --git a/src/avram/migrator/create_index_statement.cr b/src/avram/migrator/create_index_statement.cr index 2332199b0..21f085795 100644 --- a/src/avram/migrator/create_index_statement.cr +++ b/src/avram/migrator/create_index_statement.cr @@ -43,7 +43,8 @@ class Avram::Migrator::CreateIndexStatement def build index_name = @name - index_name ||= "#{@table}_#{columns.join("_")}_index" + index_name ||= "#{@table}_#{columns.join('_')}_index" + mapped_columns = columns.join(", ") { |col| %("#{col}") } String.build do |index| index << "CREATE" @@ -51,7 +52,7 @@ class Avram::Migrator::CreateIndexStatement index << " INDEX #{index_name}" index << " ON #{@table}" index << " USING #{@using.to_s.downcase}" - index << " (#{columns.join(", ")});" + index << " (#{mapped_columns});" end end diff --git a/src/avram/migrator/create_table_statement.cr b/src/avram/migrator/create_table_statement.cr index f807a3838..fe4fbaf98 100644 --- a/src/avram/migrator/create_table_statement.cr +++ b/src/avram/migrator/create_table_statement.cr @@ -80,7 +80,7 @@ class Avram::Migrator::CreateTableStatement {% if columns.size < 2 %} {% raise "composite_primary_key expected at least two primary keys, instead got #{columns.size}" %} {% end %} - constraints << " PRIMARY KEY ({{columns.join(", ").id}})" + constraints << %( PRIMARY KEY ({{columns.map { |col| %("#{col.id}") }.join(", ").id}})) end macro add_timestamps diff --git a/src/avram/query_builder.cr b/src/avram/query_builder.cr index 1d67e8703..b25c39fda 100644 --- a/src/avram/query_builder.cr +++ b/src/avram/query_builder.cr @@ -268,7 +268,7 @@ class Avram::QueryBuilder end def select(selection : Array(ColumnName)) : self - @selections = selection.join(", ") { |column| "#{@table}.#{column}" } + @selections = selection.join(", ") { |column| %("#{@table}"."#{column}") } self end