head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use v6.d;

unit class Net::Postgres::Abstract;

use Net::Postgres;
use SQL::Abstract;

my package EXPORT::functions {
	our &value = &SQL::Abstract::value;
	our &delegate = &SQL::Query::delegate;
	our &delegate-pair = &SQL::Query::delegate-pair;
	our &delegate-pairs = &SQL::Query::delegate-pairs;
}

has Net::Postgres::Connection:D $!connection is built is required handles<disconnected add-enum-type add-composite-type add-custom-type terminate get-parameter process-id query-status listen transaction>;
has SQL::Abstract:D $!abstract = SQL::Abstract.new(:placeholders<postgres>, :quoting);

method connect-tcp(|args --> Promise) {
	Net::Postgres::Connection.connect-tcp(|args).then: -> $p {
		my $connection = await $p;
		self.bless(:$connection);
	}
}

method connect-local(|args --> Promise) {
	Net::Postgres::Connection.connect-local(|args).then: -> $p {
		my $connection = await $p;
		self.bless(:$connection);
	}
}

method connect(|args --> Promise) {
	Net::Postgres::Connection.connect(|args).then: -> $p {
		my $connection = await $p;
		self.bless(:$connection);
	}
}

class PreparedStatement {
	has Net::Postgres::PreparedStatement:D $!statement is built is required handles<columns close>;
	has SQL::Query:D $!query is built is required;

	method execute(%replacements? --> Promise) {
		my @arguments = $!query.resolve(%replacements);
		$!statement.execute(@arguments);
	}
}

method !query(SQL::Query $query, Bool $prepare --> Promise) {
	if $prepare {
		$!connection.prepare($query.sql).then: -> $p {
			my $statement = await $p;
			PreparedStatement.new(:$statement, :$query);
		}
	} else {
		$!connection.query($query.sql, $query.arguments);
	}
}

multi method query(SQL::Query $query) {
	$!connection.query($query.sql, $query.arguments);
}
multi method query(Str $sql, @arguments?) {
	$!connection.query($sql, @arguments);
}
multi method query(SQL::Abstract::Expression $expression) {
	my $query = $!abstract.render($expression);
	$!connection.query($query.sql, $query.arguments);
}

multi method prepare(Str $sql) {
	$!connection.prepare($sql);
}
multi method prepare(Str $sql, @delegate-names) {
	my @arguments = @delegate-names.map(&SQL::Query::delegate);
	my $query = SQL::Query.new($sql, @arguments);
	self!query($query, True);
}

method select(Bool :$prepare, |args --> Promise) {
	self!query($!abstract.select(|args), $prepare);
}

method insert(Bool :$prepare, |args --> Promise) {
	self!query($!abstract.insert(|args), $prepare);
}

method update(Bool :$prepare, |args --> Promise) {
	self!query($!abstract.update(|args), $prepare);
}

method delete(Bool :$prepare, |args --> Promise) {
	self!query($!abstract.delete(|args), $prepare);
}

method values(Bool :$prepare, |args --> Promise) {
	self!query($!abstract.values(|args), $prepare);
}



Net::Postgres::Abstract - Abstractly and asynchronously querying your postgresql database


=begin code :lang<raku>

use Net::Postgres::Abstract;

my $dbh = await Net::Postgres::Abstract.connect-tcp(:$host, :user, :$password);

await $dbh.transaction: {
	my $row = await $dbh.insert('table', { :user<leont>, :language<raku> }, :returning<id>);
	...
}

my $results = await $dbh.select('table', <user password country>, { :age('>' => 25) });
for $results.objects(User) -> $user {
	...
}

my $sth = await $dbh.select('table', *, { :id(delegate('id')) }, :prepare);
for @ids -> $id {
	my $row = await $sth->execute(:$id);
	...
}

=end code


Net::Postgres::Abstract is at its core a combination of query builder C<SQL::Abstract> and postgresql client C<Net::Postgres>.


item

It abstracts the generation of SQL queries, so you don't have to write them yourself.


All queries are performed asynchronously.


Full support for prepared queries, including named substitution, is offered.


This creates a promise to a new C<Net::Postgres::Abstract> client. It takes the following named arguments:


This creates a new C<Net::Postgres::Abstract> client much like C<connect-tcp>, but does so via a unix domain socket.


This takes the same arguments as C<connect-local> and C<connect-tcp>. It will call the former if the C<$host> is localhost and the C<$path> exists, otherwise it will call C<connect-tcp>.


All these methods return a Promise. if a C<:$prepared> argument is given to them the Promise will contain a C<Net::Postgres::Abstract::PreparedStatement> object, otherwise it will be the usual C<Net::Postgres> return type (usually a C<Net::Postgres::ResultSet> if it returns rows, or a C<Str> if it doesn't).


=begin code :lang<raku>

method select(Source(Any) $source, Column::List(Any) $columns = *, Conditions(Any) $where?, Common(Any) :$common,
Distinction(Any) :$distinct, GroupBy(Any) :$group-by, Conditions(Any) :$having, Window::Clauses(Any) :$windows,
Compound(Pair) :$compound, OrderBy(Any) :$order-by, Int :$limit, Int :$offset, Locking(Any) :$locking)

=end code


This will generate a C<SELECT> query. It will select C<$columns> from C<$source>, filtering by $conditions.


=begin code :lang<raku>

my $join = { :left<books>, :right<authors>, :using<author_id> };
my $result = $abstract.select($join, ['books.name', 'authors.name'], { :cost('<' => 10) });
# SELECT books.name, authors.name FROM books INNER JOIN authors USING (author_id) WHERE cost < 10

my $counts = $abstract.select('artists',
    [ 'name', :number(:count(*)) ],
    { :name(like => 'A%') },
    :group-by<name>, :order-by(:number<desc>));
# SELECT name, COUNT(*) as number FROM artists WHERE name LIKE 'A%' GROUP BY name ORDER BY number DESC

=end code


=begin code :lang<raku>

method update(Table(Any) $target, Assigns(Any) $assigns, Conditions(Any) $where?,
Common(Any) :$common, Source(Any) :$from, Column::List(Any) :$returning)

=end code


This will update C<$target> by assigning the columns and values from C<$set> if they match C<$where>, returning C<$returning>.


=begin code :lang<raku>

$abtract.update('artists', { :name('The Artist (Formerly Known as Prince)') }, { :name<Prince> });
# UPDATE artists SET name = 'The Artist (Formerly Known as Prince)' WHERE name = 'Prince'

=end code


=begin code :lang<raku>

method insert(Table(Any) $target, Assigns(Any) $values, Common(Any) :$common,
Overriding(Str) :$overriding, Conflicts(Any) :$conflicts, Column::List(Any) :$returning)

=end code


Inserts the values in C<$values> into the table C<$target>, returning the columns in C<$returning>


=begin code :lang<raku>

$abstract.insert('artists', { :name<Metallica> }, :returning(*));
# INSERT INTO artists (name) VALUES ('Metallica') RETURNING *

=end code


=begin code :lang<raku>

method insert(Table(Any) $target, Identifiers(Any) $columns, Rows(List) $rows, Common(Any) :$common,
Overriding(Str) :$overriding, Conflicts(Any) :$conflicts, Column::List(Any) :$returning)

=end code


Insert into C<$target>, assigning each of the values in Rows to a new row in the table. This way one can insert a multitude of rows into a table.


=begin code :lang<raku>

$abstract.insert('artists', ['name'], [ ['Metallica'], ['Motörhead'] ], :returning(*));
# INSERT INTO artists (name) VALUES ('Metallica'), ('Motörhead') RETURNING *

$abstract.insert('artists', List, [ [ 'Metallica'], ], :returning<id>);
# INSERT INTO artists VALUES ('Metallica') RETURNING id

=end code


=begin code :lang<raku>

method insert(Table(Any) $target, Identifiers(Any) $columns, Select(Map) $select, Common(Any) :$common,
Overriding(Str) :$overriding, Conflicts(Any) :$conflicts, Column::List(Any) :$returning)

=end code


This selects from a (usually different) table, and inserts the values into the table.


=begin code :lang<raku>

$abstract.insert('artists', 'name', { :source<new_artists>, :columns<name> }, :returning(*));
# INSERT INTO artists (name) SELECT name FROM new_artists RETURNING *

=end code


=begin code :lang<raku>

method delete(Table:D(Any:D) $target, Conditions(Any) $where, Common(Any) :$common,
Source(Any) :$using, Column::List(Any) :$returning)

=end code


This deletes rows from the database, optionally returning their values.


=begin code :lang<raku>

$abstract.delete('artists', { :name<Madonna> });
# DELETE FROM artists WHERE name = 'Madonna'

=end code


=begin code :lang<raku>

method query(Str $sql, @arguments?)
method query(SQL::Query $query)
method query(SQL::Abstract::Expression $query)

=end code


Abstract

=begin code :lang<raku>

use Net::NetRC;

=end code


Humberto Massa <humbertomassa@gmail.com>


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.



use Grammar::Tracer;

grammar NetRC {
    token ws { <!ww> \s*! [ '#' \s*! <content> \n \s* ]* }
    token content { \N* }
    token machine-definition {
        [ <default-def> | <machine-def> ]
        [ <login-def> | <password-def> | <account-def> ]*
    }
    rule default-def { default }
    rule machine-def { machine (\S*) }
    rule login-def { login (\S+) }
    rule password-def { password (\S+) }
    rule account-def { account (\S+) }
    token rest { .* }
    token TOP { <ws> [ <machine-definition> <ws> ]* }
}

class Actions {
    use Hash::Agnostic;
    my class DefaultableHash does Hash::Agnostic {
        has %!storage;
        has $!default;
        method keys() { %!storage ?? ( '', %!storage.keys.sort.Slip, ) !! () }
        method AT-KEY($k) is raw { %!storage{$k} :exists ?? %!storage{$k} !! $!default }
        method ASSIGN-KEY($k, Mu \v) is raw { ( $k ?? %!storage{$k} !! $!default ) = v }
        method DELETE-KEY($k) is raw { $k ?? ( %!storage{$k}:delete ) !! ( $!default = Nil ) }
    }
    method TOP($/) {
        my @x = $/<machine-definition>.map({
            .<default-def machine-def>.Slip,
            .<login-def password-def account-def>».first(:end).Slip
        })».made».grep(*.so)».Hash;
        my DefaultableHash $h .= new;
        $h{ .<name> :delete } = $_ for @x;
        make $h
    }
    method default-def($/)  { make ( name => ''         ) }
    method machine-def($/)  { make ( name => ~$/[0]     ) }
    method login-def($/)    { make ( login => ~$/[0]    ) }
    method password-def($/) { make ( password => ~$/[0] ) }
    method account-def($/)  { make ( account => ~$/[0]  ) }
}

multi sub netrc() is export {
    state $netrc = netrc "%*ENV<HOME>/.netrc".IO;
    $netrc
}

multi sub netrc(IO() $handle) is export { netrc $handle.slurp }

multi sub netrc(Str() $s) is export {
    return netrc $s.IO if $s.IO.r;
    my Actions $actions .= new;
    my $x = NetRC.parse( $s, :$actions ).made
}



NetRC

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

Net::NetRC v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation