Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/awncorp/sql-engine
SQL Generation for Perl 5
https://github.com/awncorp/sql-engine
json-sql perl perl5 sql
Last synced: about 2 months ago
JSON representation
SQL Generation for Perl 5
- Host: GitHub
- URL: https://github.com/awncorp/sql-engine
- Owner: awncorp
- License: other
- Created: 2020-07-25T17:21:12.000Z (over 4 years ago)
- Default Branch: master
- Last Pushed: 2020-08-16T02:31:20.000Z (over 4 years ago)
- Last Synced: 2023-08-20T22:28:27.042Z (over 1 year ago)
- Topics: json-sql, perl, perl5, sql
- Language: Perl
- Homepage: https://metacpan.org/release/SQL-Engine
- Size: 159 KB
- Stars: 1
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README
- Changelog: CHANGES
- Contributing: CONTRIBUTING.md
- License: LICENSE
- Code of conduct: CODE_OF_CONDUCT.md
Awesome Lists containing this project
README
NAME
SQL::Engine - SQL Generation
ABSTRACT
SQL Generation for Perl 5
SYNOPSIS
use SQL::Engine;
my $sql = SQL::Engine->new;
$sql->insert(
into => {
table => 'users'
},
columns => [
{
column => 'id'
},
{
column => 'name'
}
],
values => [
{
value => undef
},
{
value => {
binding => 'name'
}
},
]
);
# then, e.g.
#
# my $dbh = DBI->connect;
#
# for my $operation ($sql->operations->list) {
# my $statement = $operation->statement;
# my @bindings = $operation->parameters({ name => 'Rob Zombie' });
#
# my $sth = $dbh->prepate($statement);
#
# $sth->execute(@bindings);
# }
#
# $dbh->disconnect;
DESCRIPTION
This package provides an interface and builders which generate SQL
statements, by default using a standard SQL syntax or vendor-specific
syntax if supported and provided to the constructor using the "grammar"
property. This package does not require a database connection, by
design, which gives users complete control over how connections and
statement handles are managed.
LIBRARIES
This package uses type constraints from:
Types::Standard
SCENARIOS
This package supports the following scenarios:
validation
use SQL::Engine;
my $sql = SQL::Engine->new(
validator => undef
);
# faster, no-validation
$sql->select(
from => {
table => 'users'
},
columns => [
{
column => '*'
}
]
);
This package supports automatic validation of operations using
SQL::Validator which can be passed to the constructor as the value of
the "validator" property. This object will be generated if not
provided. Alternatively, automated validation can be disabled by
passing the "undefined" value to the "validator" property on object
construction. Doing so enhances the performance of SQL generation at
the cost of not verifying that the instructions provided are correct.
ATTRIBUTES
This package has the following attributes:
grammar
grammar(Str)
This attribute is read-only, accepts (Str) values, and is optional.
operations
operations(InstanceOf["SQL::Engine::Collection"])
This attribute is read-only, accepts
(InstanceOf["SQL::Engine::Collection"]) values, and is optional.
validator
validator(Maybe[InstanceOf["SQL::Validator"]])
This attribute is read-only, accepts
(Maybe[InstanceOf["SQL::Validator"]]) values, and is optional.
METHODS
This package implements the following methods:
column_change
column_change(Any %args) : Object
The column_change method produces SQL operations which changes a table
column definition. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::ColumnChange.
column_change example #1
# given: synopsis
$sql->operations->clear;
$sql->column_change(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime',
nullable => 1
}
);
column_create
column_create(Any %args) : Object
The column_create method produces SQL operations which create a new
table column. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::ColumnCreate.
column_create example #1
# given: synopsis
$sql->operations->clear;
$sql->column_create(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime'
}
);
column_drop
column_drop(Any %args) : Object
The column_drop method produces SQL operations which removes an
existing table column. The arguments expected are the constructor
arguments accepted by SQL::Engine::Builder::ColumnDrop.
column_drop example #1
# given: synopsis
$sql->operations->clear;
$sql->column_drop(
table => 'users',
column => 'accessed'
);
column_rename
column_rename(Any %args) : Object
The column_rename method produces SQL operations which renames an
existing table column. The arguments expected are the constructor
arguments accepted by SQL::Engine::Builder::ColumnRename.
column_rename example #1
# given: synopsis
$sql->operations->clear;
$sql->column_rename(
for => {
table => 'users'
},
name => {
old => 'accessed',
new => 'accessed_at'
}
);
constraint_create
constraint_create(Any %args) : Object
The constraint_create method produces SQL operations which creates a
new table constraint. The arguments expected are the constructor
arguments accepted by SQL::Engine::Builder::ConstraintCreate.
constraint_create example #1
# given: synopsis
$sql->operations->clear;
$sql->constraint_create(
source => {
table => 'users',
column => 'profile_id'
},
target => {
table => 'profiles',
column => 'id'
}
);
constraint_drop
constraint_drop(Any %args) : Object
The constraint_drop method produces SQL operations which removes an
existing table constraint. The arguments expected are the constructor
arguments accepted by SQL::Engine::Builder::ConstraintDrop.
constraint_drop example #1
# given: synopsis
$sql->operations->clear;
$sql->constraint_drop(
source => {
table => 'users',
column => 'profile_id'
},
target => {
table => 'profiles',
column => 'id'
}
);
database_create
database_create(Any %args) : Object
The database_create method produces SQL operations which creates a new
database. The arguments expected are the constructor arguments accepted
by SQL::Engine::Builder::DatabaseCreate.
database_create example #1
# given: synopsis
$sql->operations->clear;
$sql->database_create(
name => 'todoapp'
);
database_drop
database_drop(Any %args) : Object
The database_drop method produces SQL operations which removes an
existing database. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::DatabaseDrop.
database_drop example #1
# given: synopsis
$sql->operations->clear;
$sql->database_drop(
name => 'todoapp'
);
delete
delete(Any %args) : Object
The delete method produces SQL operations which deletes rows from a
table. The arguments expected are the constructor arguments accepted by
SQL::Engine::Builder::Delete.
delete example #1
# given: synopsis
$sql->operations->clear;
$sql->delete(
from => {
table => 'tasklists'
}
);
index_create
index_create(Any %args) : Object
The index_create method produces SQL operations which creates a new
table index. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::IndexCreate.
index_create example #1
# given: synopsis
$sql->operations->clear;
$sql->index_create(
for => {
table => 'users'
},
columns => [
{
column => 'name'
}
]
);
index_drop
index_drop(Any %args) : Object
The index_drop method produces SQL operations which removes an existing
table index. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::IndexDrop.
index_drop example #1
# given: synopsis
$sql->operations->clear;
$sql->index_drop(
for => {
table => 'users'
},
columns => [
{
column => 'name'
}
]
);
insert
insert(Any %args) : Object
The insert method produces SQL operations which inserts rows into a
table. The arguments expected are the constructor arguments accepted by
SQL::Engine::Builder::Insert.
insert example #1
# given: synopsis
$sql->operations->clear;
$sql->insert(
into => {
table => 'users'
},
values => [
{
value => undef
},
{
value => 'Rob Zombie'
},
{
value => {
function => ['now']
}
},
{
value => {
function => ['now']
}
},
{
value => {
function => ['now']
}
}
]
);
schema_create
schema_create(Any %args) : Object
The schema_create method produces SQL operations which creates a new
schema. The arguments expected are the constructor arguments accepted
by SQL::Engine::Builder::SchemaCreate.
schema_create example #1
# given: synopsis
$sql->operations->clear;
$sql->schema_create(
name => 'private',
);
schema_drop
schema_drop(Any %args) : Object
The schema_drop method produces SQL operations which removes an
existing schema. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::SchemaDrop.
schema_drop example #1
# given: synopsis
$sql->operations->clear;
$sql->schema_drop(
name => 'private',
);
schema_rename
schema_rename(Any %args) : Object
The schema_rename method produces SQL operations which renames an
existing schema. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::SchemaRename.
schema_rename example #1
# given: synopsis
$sql->operations->clear;
$sql->schema_rename(
name => {
old => 'private',
new => 'restricted'
}
);
select
select(Any %args) : Object
The select method produces SQL operations which select rows from a
table. The arguments expected are the constructor arguments accepted by
SQL::Engine::Builder::Select.
select example #1
# given: synopsis
$sql->operations->clear;
$sql->select(
from => {
table => 'people'
},
columns => [
{ column => 'name' }
]
);
table_create
table_create(Any %args) : Object
The table_create method produces SQL operations which creates a new
table. The arguments expected are the constructor arguments accepted by
SQL::Engine::Builder::TableCreate.
table_create example #1
# given: synopsis
$sql->operations->clear;
$sql->table_create(
name => 'users',
columns => [
{
name => 'id',
type => 'integer',
primary => 1
}
]
);
table_drop
table_drop(Any %args) : Object
The table_drop method produces SQL operations which removes an existing
table. The arguments expected are the constructor arguments accepted by
SQL::Engine::Builder::TableDrop.
table_drop example #1
# given: synopsis
$sql->operations->clear;
$sql->table_drop(
name => 'people'
);
table_rename
table_rename(Any %args) : Object
The table_rename method produces SQL operations which renames an
existing table. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::TableRename.
table_rename example #1
# given: synopsis
$sql->operations->clear;
$sql->table_rename(
name => {
old => 'peoples',
new => 'people'
}
);
transaction
transaction(Any %args) : Object
The transaction method produces SQL operations which represents an
atomic database operation. The arguments expected are the constructor
arguments accepted by SQL::Engine::Builder::Transaction.
transaction example #1
# given: synopsis
$sql->operations->clear;
$sql->transaction(
queries => [
{
'table-create' => {
name => 'users',
columns => [
{
name => 'id',
type => 'integer',
primary => 1
}
]
}
}
]
);
union
union(Any %args) : Object
The union method produces SQL operations which returns a results from
two or more select queries. The arguments expected are the constructor
arguments accepted by SQL::Engine::Builder::Union.
union example #1
# given: synopsis
$sql->operations->clear;
$sql->union(
queries => [
{
select => {
from => {
table => 'customers',
},
columns => [
{
column => 'name',
}
]
}
},
{
select => {
from => {
table => 'employees',
},
columns => [
{
column => 'name',
}
]
}
}
]
);
update
update(Any %args) : Object
The update method produces SQL operations which update rows in a table.
The arguments expected are the constructor arguments accepted by
SQL::Engine::Builder::Update.
update example #1
# given: synopsis
$sql->operations->clear;
$sql->update(
for => {
table => 'users'
},
columns => [
{
column => 'updated',
value => { function => ['now'] }
}
]
);
view_create
view_create(Any %args) : Object
The view_create method produces SQL operations which creates a new
table view. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::ViewCreate.
view_create example #1
# given: synopsis
$sql->operations->clear;
$sql->view_create(
name => 'active_users',
query => {
select => {
from => {
table => 'users'
},
columns => [
{
column => '*'
}
],
where => [
{
'not-null' => {
column => 'deleted'
}
}
]
}
}
);
view_drop
view_drop(Any %args) : Object
The view_drop method produces SQL operations which removes an existing
table view. The arguments expected are the constructor arguments
accepted by SQL::Engine::Builder::ViewDrop.
view_drop example #1
# given: synopsis
$sql->operations->clear;
$sql->view_drop(
name => 'active_users'
);
EXAMPLES
This distribution supports generating SQL statements using standard
syntax or using database-specific syntax if a grammar is specified. The
following is a collection of examples covering the most common
operations (using PostgreSQL syntax):
setup
use SQL::Engine;
my $sql = SQL::Engine->new(
grammar => 'postgres'
);
$sql->select(
from => {
table => 'people'
},
columns => [
{ column => 'name' }
]
);
$sql->operations->first->statement;
# SELECT "name" FROM "people"
select
select example #1
$sql->select(
from => {
table => 'users'
},
columns => [
{
column => '*'
}
]
);
select example #1 output
# SELECT * FROM "users"
select example #2
$sql->select(
from => {
table => 'users'
},
columns => [
{
column => 'id'
},
{
column => 'name'
}
]
);
select example #2 output
# SELECT "id", "name" FROM "users"
select example #3
$sql->select(
from => {
table => 'users'
},
columns => [
{
column => '*'
}
],
where => [
{
eq => [{column => 'id'}, {binding => 'id'}]
}
]
);
select example #3 output
# SELECT * FROM "users" WHERE "id" = ?
select example #4
$sql->select(
from => {
table => 'users',
alias => 'u'
},
columns => [
{
column => '*',
alias => 'u'
}
],
joins => [
{
with => {
table => 'tasklists',
alias => 't'
},
having => [
{
eq => [
{
column => 'id',
alias => 'u'
},
{
column => 'user_id',
alias => 't'
}
]
}
]
}
],
where => [
{
eq => [
{
column => 'id',
alias => 'u'
},
{
binding => 'id'
}
]
}
]
);
select example #4 output
# SELECT "u".* FROM "users" "u"
# JOIN "tasklists" "t" ON "u"."id" = "t"."user_id" WHERE "u"."id" = ?
select example #5
$sql->select(
from => {
table => 'tasklists'
},
columns => [
{
function => ['count', { column => 'user_id' }]
}
],
group_by => [
{
column => 'user_id'
}
]
);
select example #5 output
# SELECT count("user_id") FROM "tasklists" GROUP BY "user_id"
select example #6
$sql->select(
from => {
table => 'tasklists'
},
columns => [
{
function => ['count', { column => 'user_id' }]
}
],
group_by => [
{
column => 'user_id'
}
],
having => [
{
gt => [
{
function => ['count', { column => 'user_id' }]
},
1
]
}
]
);
select example #6 output
# SELECT count("user_id") FROM "tasklists" GROUP BY "user_id" HAVING
# count("user_id") > 1
select example #7
$sql->select(
from => {
table => 'tasklists'
},
columns => [
{
column => '*'
}
],
order_by => [
{
column => 'user_id'
}
]
);
select example #7 output
# SELECT * FROM "tasklists" ORDER BY "user_id"
select example #8
$sql->select(
from => {
table => 'tasklists'
},
columns => [
{
column => '*'
}
],
order_by => [
{
column => 'user_id'
},
{
column => 'id',
sort => 'desc'
}
]
);
select example #8 output
# SELECT * FROM "tasklists" ORDER BY "user_id", "id" DESC
select example #9
$sql->select(
from => {
table => 'tasks'
},
columns => [
{
column => '*'
}
],
rows => {
limit => 5
}
);
select example #9 output
# SELECT * FROM "tasks" LIMIT 5
select example #10
$sql->select(
from => {
table => 'tasks'
},
columns => [
{
column => '*'
}
],
rows => {
limit => 5,
offset => 1
}
);
select example #10 output
# SELECT * FROM "tasks" LIMIT 5, OFFSET 1
select example #11
$sql->select(
from => [
{
table => 'tasklists',
alias => 't1'
},
{
table => 'tasks',
alias => 't2'
}
],
columns => [
{
column => '*',
alias => 't1'
},
{
column => '*',
alias => 't1'
}
],
where => [
{
eq => [
{
column => 'tasklist_id',
alias => 't2'
},
{
column => 'id',
alias => 't1'
}
]
}
]
);
select example #11 output
# SELECT "t1".*, "t1".* FROM "tasklists" "t1", "tasks" "t2"
# WHERE "t2"."tasklist_id" = "t1"."id"
insert
insert example #1
$sql->insert(
into => {
table => 'users'
},
values => [
{
value => undef
},
{
value => 'Rob Zombie'
},
{
value => {
function => ['now']
}
},
{
value => {
function => ['now']
}
},
{
value => {
function => ['now']
}
}
]
);
insert example #1 output
# INSERT INTO "users" VALUES (NULL, 'Rob Zombie', now(), now(), now())
insert example #2
$sql->insert(
into => {
table => 'users'
},
columns => [
{
column => 'id'
},
{
column => 'name'
},
{
column => 'created'
},
{
column => 'updated'
},
{
column => 'deleted'
}
],
values => [
{
value => undef
},
{
value => 'Rob Zombie'
},
{
value => {
function => ['now']
}
},
{
value => {
function => ['now']
}
},
{
value => {
function => ['now']
}
}
]
);
insert example #2 output
# INSERT INTO "users" ("id", "name", "created", "updated", "deleted")
# VALUES (NULL, 'Rob Zombie', now(), now(), now())
insert example #3
$sql->insert(
into => {
table => 'users'
},
default => 1
);
insert example #3 output
# INSERT INTO "users" DEFAULT VALUES
insert example #4
$sql->insert(
into => {
table => 'users'
},
columns => [
{
column => 'name'
},
{
column => 'user_id'
}
],
query => {
select => {
from => {
table => 'users'
},
columns => [
{
column => 'name'
},
{
column => 'id'
}
]
}
}
);
insert example #4 output
# INSERT INTO "users" ("name", "user_id") SELECT "name", "id" FROM "users"
insert example #5
$sql->insert(
into => {
table => 'users'
},
columns => [
{
column => 'name'
},
{
column => 'user_id'
}
],
query => {
select => {
from => {
table => 'users'
},
columns => [
{
column => 'name'
},
{
column => 'id'
}
],
where => [
{
'not-null' => {
column => 'deleted'
}
}
]
}
}
);
insert example #5 output
# INSERT INTO "users" ("name", "user_id") SELECT "name", "id" FROM "users"
# WHERE "deleted" IS NOT NULL
update
update example #1
$sql->update(
for => {
table => 'users'
},
columns => [
{
column => 'updated',
value => { function => ['now'] }
}
]
);
update example #1 output
# UPDATE "users" SET "updated" = now()
update example #2
$sql->update(
for => {
table => 'users'
},
columns => [
{
column => 'name',
value => { function => ['concat', '[deleted]', ' ', { column => 'name' }] }
}
],
where => [
{
'not-null' => {
column => 'deleted'
}
}
]
);
update example #2 output
# UPDATE "users" SET "name" = concat('[deleted]', ' ', "name") WHERE
# "deleted" IS NOT NULL
update example #3
$sql->update(
for => {
table => 'users',
alias => 'u1'
},
columns => [
{
column => 'updated',
alias => 'u1',
value => { function => ['now'] }
}
],
where => [
{
in => [
{
column => 'id',
alias => 'u1'
},
{
subquery => {
select => {
from => {
table => 'users',
alias => 'u2'
},
columns => [
{
column => 'id',
alias => 'u2'
}
],
joins => [
{
with => {
table => 'tasklists',
alias => 't1'
},
having => [
{
eq => [
{
column => 'id',
alias => 'u2'
},
{
column => 'user_id',
alias => 't1'
}
]
}
]
}
],
where => [
{
eq => [
{
column => 'id',
alias => 'u2'
},
{
binding => 'user_id'
}
]
}
]
}
}
}
]
}
]
);
update example #3 output
# UPDATE "users" "u1" SET "u1"."updated" = now() WHERE "u1"."id" IN (SELECT
# "u2"."id" FROM "users" "u2" JOIN "tasklists" "t1" ON "u2"."id" =
# "t1"."user_id" WHERE "u2"."id" = ?)
delete
delete example #1
$sql->delete(
from => {
table => 'tasklists'
}
);
delete example #1 output
# DELETE FROM "tasklists"
delete example #2
$sql->delete(
from => {
table => 'tasklists'
},
where => [
{
'not-null' => {
column => 'deleted'
}
}
]
);
delete example #2 output
# DELETE FROM "tasklists" WHERE "deleted" IS NOT NULL
table-create
table-create example #1
$sql->table_create(
name => 'users',
columns => [
{
name => 'id',
type => 'integer',
primary => 1
}
]
);
table-create example #1 output
# CREATE TABLE "users" ("id" integer PRIMARY KEY)
table-create example #2
$sql->table_create(
name => 'users',
columns => [
{
name => 'id',
type => 'integer',
primary => 1
},
{
name => 'name',
type => 'text',
},
{
name => 'created',
type => 'datetime',
},
{
name => 'updated',
type => 'datetime',
},
{
name => 'deleted',
type => 'datetime',
},
]
);
table-create example #2 output
# CREATE TABLE "users" ("id" integer PRIMARY KEY, "name" text, "created"
# timestamp(0) without time zone, "updated" timestamp(0) without time zone,
# "deleted" timestamp(0) without time zone)
table-create example #3
$sql->table_create(
name => 'users',
columns => [
{
name => 'id',
type => 'integer',
primary => 1
},
{
name => 'name',
type => 'text',
},
{
name => 'created',
type => 'datetime',
},
{
name => 'updated',
type => 'datetime',
},
{
name => 'deleted',
type => 'datetime',
},
],
temp => 1
);
table-create example #3 output
# CREATE TEMPORARY TABLE "users" ("id" integer PRIMARY KEY, "name" text,
# "created" timestamp(0) without time zone, "updated" timestamp(0) without
# time zone, "deleted" timestamp(0) without time zone)
table-create example #4
$sql->table_create(
name => 'people',
query => {
select => {
from => {
table => 'users'
},
columns => [
{
column => '*'
}
]
}
}
);
table-create example #4 output
# CREATE TABLE "people" AS SELECT * FROM "users"
table-drop
table-drop example #1
$sql->table_drop(
name => 'people'
);
table-drop example #1 output
# DROP TABLE "people"
table-drop example #2
$sql->table_drop(
name => 'people',
condition => 'cascade'
);
table-drop example #2 output
# DROP TABLE "people" CASCADE
table-rename
table-rename example #1
$sql->table_rename(
name => {
old => 'peoples',
new => 'people'
}
);
table-rename example #1 output
# ALTER TABLE "peoples" RENAME TO "people"
index-create
index-create example #1
$sql->index_create(
for => {
table => 'users'
},
columns => [
{
column => 'name'
}
]
);
index-create example #1 output
# CREATE INDEX "index_users_name" ON "users" ("name")
index-create example #2
$sql->index_create(
for => {
table => 'users'
},
columns => [
{
column => 'email'
}
],
unique => 1
);
index-create example #2 output
# CREATE UNIQUE INDEX "unique_users_email" ON "users" ("email")
index-create example #3
$sql->index_create(
for => {
table => 'users'
},
columns => [
{
column => 'name'
}
],
name => 'user_name_index'
);
index-create example #3 output
# CREATE INDEX "user_name_index" ON "users" ("name")
index-create example #4
$sql->index_create(
for => {
table => 'users'
},
columns => [
{
column => 'email'
}
],
name => 'user_email_unique',
unique => 1
);
index-create example #4 output
# CREATE UNIQUE INDEX "user_email_unique" ON "users" ("email")
index-create example #5
$sql->index_create(
for => {
table => 'users'
},
columns => [
{
column => 'login'
},
{
column => 'email'
}
]
);
index-create example #5 output
# CREATE INDEX "index_users_login_email" ON "users" ("login", "email")
index-drop
index-drop example #1
$sql->index_drop(
for => {
table => 'users'
},
columns => [
{
column => 'name'
}
]
);
index-drop example #1 output
# DROP INDEX "index_users_name"
index-drop example #2
$sql->index_drop(
for => {
table => 'users'
},
columns => [
{
column => 'email'
}
],
unique => 1
);
index-drop example #2 output
# DROP INDEX "unique_users_email"
index-drop example #3
$sql->index_drop(
for => {
table => 'users'
},
columns => [
{
column => 'name'
}
],
name => 'user_email_unique'
);
index-drop example #3 output
# DROP INDEX "user_email_unique"
column-change
column-change example #1
$sql->column_change(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime',
nullable => 1
}
);
column-change example #1 output
# BEGIN TRANSACTION
# ALTER TABLE "users" ALTER "accessed" TYPE timestamp(0) without time zone
# ALTER TABLE "users" ALTER "accessed" DROP NOT NULL
# ALTER TABLE "users" ALTER "accessed" DROP DEFAULT
# COMMIT
column-change example #2
$sql->column_change(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime',
default => { function => ['now'] }
}
);
column-change example #2 output
# BEGIN TRANSACTION
# ALTER TABLE "users" ALTER "accessed" TYPE timestamp(0) without time zone
# ALTER TABLE "users" ALTER "accessed" SET DEFAULT now()
# COMMIT
column-change example #3
$sql->column_change(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime',
default => { function => ['now'] },
nullable => 1,
}
);
column-change example #3 output
# BEGIN TRANSACTION
# ALTER TABLE "users" ALTER "accessed" TYPE timestamp(0) without time zone
# ALTER TABLE "users" ALTER "accessed" DROP NOT NULL
# ALTER TABLE "users" ALTER "accessed" SET DEFAULT now()
# COMMIT
column-create
column-create example #1
$sql->column_create(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime'
}
);
column-create example #1 output
# ALTER TABLE "users" ADD COLUMN "accessed" timestamp(0) without time zone
column-create example #2
$sql->column_create(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime',
nullable => 1
}
);
column-create example #2 output
# ALTER TABLE "users" ADD COLUMN "accessed" timestamp(0) without time zone
# NULL
column-create example #3
$sql->column_create(
for => {
table => 'users'
},
column => {
name => 'accessed',
type => 'datetime',
nullable => 1,
default => {
function => ['now']
}
}
);
column-create example #3 output
# ALTER TABLE "users" ADD COLUMN "accessed" timestamp(0) without time zone
# NULL DEFAULT now()
column-create example #4
$sql->column_create(
for => {
table => 'users'
},
column => {
name => 'ref',
type => 'uuid',
primary => 1
}
);
column-create example #4 output
# ALTER TABLE "users" ADD COLUMN "ref" uuid PRIMARY KEY
column-drop
column-drop example #1
$sql->column_drop(
table => 'users',
column => 'accessed'
);
column-drop example #1 output
# ALTER TABLE "users" DROP COLUMN "accessed"
column-rename
column-rename example #1
$sql->column_rename(
for => {
table => 'users'
},
name => {
old => 'accessed',
new => 'accessed_at'
}
);
column-rename example #1 output
# ALTER TABLE "users" RENAME COLUMN "accessed" TO "accessed_at"
constraint-create
constraint-create example #1
$sql->constraint_create(
source => {
table => 'users',
column => 'profile_id'
},
target => {
table => 'profiles',
column => 'id'
}
);
constraint-create example #1 output
# ALTER TABLE "users" ADD CONSTRAINT "foreign_users_profile_id_profiles_id"
# FOREIGN KEY ("profile_id") REFERENCES "profiles" ("id")
constraint-create example #2
$sql->constraint_create(
source => {
table => 'users',
column => 'profile_id'
},
target => {
table => 'profiles',
column => 'id'
},
name => 'user_profile_id'
);
constraint-create example #2 output
# ALTER TABLE "users" ADD CONSTRAINT "user_profile_id" FOREIGN KEY
# ("profile_id") REFERENCES "profiles" ("id")
constraint-create example #3
$sql->constraint_create(
on => {
update => 'cascade',
delete => 'cascade'
},
source => {
table => 'users',
column => 'profile_id'
},
target => {
table => 'profiles',
column => 'id'
},
name => 'user_profile_id'
);
constraint-create example #3 output
# ALTER TABLE "users" ADD CONSTRAINT "user_profile_id" FOREIGN KEY
# ("profile_id") REFERENCES "profiles" ("id") ON DELETE CASCADE ON UPDATE
# CASCADE
constraint-drop
constraint-drop example #1
$sql->constraint_drop(
source => {
table => 'users',
column => 'profile_id'
},
target => {
table => 'profiles',
column => 'id'
}
);
constraint-drop example #1 output
# ALTER TABLE "users" DROP CONSTRAINT "foreign_users_profile_id_profiles_id"
constraint-drop example #2
$sql->constraint_drop(
source => {
table => 'users',
column => 'profile_id'
},
target => {
table => 'profiles',
column => 'id'
},
name => 'user_profile_id'
);
constraint-drop example #2 output
# ALTER TABLE "users" DROP CONSTRAINT "user_profile_id"
database-create
database-create example #1
$sql->database_create(
name => 'todoapp'
);
database-create example #1 output
# CREATE DATABASE "todoapp"
database-drop
database-drop example #1
$sql->database_drop(
name => 'todoapp'
);
database-drop example #1 output
# DROP DATABASE "todoapp"
schema-create
schema-create example #1
$sql->schema_create(
name => 'private',
);
schema-create example #1 output
# CREATE SCHEMA "private"
schema-drop
schema-drop example #1
$sql->schema_drop(
name => 'private',
);
schema-drop example #1 output
# DROP SCHEMA "private"
schema-rename
schema-rename example #1
$sql->schema_rename(
name => {
old => 'private',
new => 'restricted'
}
);
schema-rename example #1 output
# ALTER SCHEMA "private" RENAME TO "restricted"
transaction
transaction example #1
$sql->transaction(
queries => [
{
'table-create' => {
name => 'users',
columns => [
{
name => 'id',
type => 'integer',
primary => 1
}
]
}
}
]
);
transaction example #1 output
# BEGIN TRANSACTION
# CREATE TABLE "users" ("id" integer PRIMARY KEY)
# COMMIT
transaction example #2
$sql->transaction(
mode => [
'exclusive'
],
queries => [
{
'table-create' => {
name => 'users',
columns => [
{
name => 'id',
type => 'integer',
primary => 1
}
]
}
}
]
);
transaction example #2 output
# BEGIN TRANSACTION EXCLUSIVE
# CREATE TABLE "users" ("id" integer PRIMARY KEY)
# COMMIT
view-create
view-create example #1
$sql->view_create(
name => 'active_users',
query => {
select => {
from => {
table => 'users'
},
columns => [
{
column => '*'
}
],
where => [
{
'not-null' => {
column => 'deleted'
}
}
]
}
}
);
view-create example #1 output
# CREATE VIEW "active_users" AS SELECT * FROM "users" WHERE "deleted" IS NOT
# NULL
view-create example #2
$sql->view_create(
name => 'active_users',
query => {
select => {
from => {
table => 'users'
},
columns => [
{
column => '*'
}
],
where => [
{
'not-null' => {
column => 'deleted'
}
}
]
}
},
temp => 1
);
view-create example #2 output
# CREATE TEMPORARY VIEW "active_users" AS SELECT * FROM "users" WHERE
# "deleted" IS NOT NULL
view-drop
view-drop example #1
$sql->view_drop(
name => 'active_users'
);
view-drop example #1 output
# DROP VIEW "active_users"
union
union example #1
$sql->union(
queries => [
{
select => {
from => {
table => 'customers',
},
columns => [
{
column => 'name',
}
]
}
},
{
select => {
from => {
table => 'employees',
},
columns => [
{
column => 'name',
}
]
}
}
]
);
union example #1 output
# (SELECT "name" FROM "customers") UNION (SELECT "name" FROM "employees")
AUTHOR
Al Newkirk, [email protected]
LICENSE
Copyright (C) 2011-2019, Al Newkirk, et al.
This is free software; you can redistribute it and/or modify it under
the terms of the The Apache License, Version 2.0, as elucidated in the
"license file"
.
PROJECT
Wiki
Project
Initiatives
Milestones
Contributing
Issues