DBIx::Class beginners

leo lapworth
leo lapworthSenior Web Developer
DBIx::Class (aka DBIC)
      for (advanced) beginners



     Leo Lapworth @ LPW 2008

    http://leo.cuckoo.org/projects/
assumptions

   You know a little about Perl
   and using objects

   You know a little bit about
   databases and using foreign
   keys
DBIx::Class?
•   ORM (object relational mapper)

•   SQL <-> OO (using objects instead of SQL)

•   Simple, powerful, complex, fab and confusing

•   There are many ORMs, DBIx::Class just happens to
    be the best in Perl (personal opinion)
why this talk?
• Help avoid mistakes I made!
• Help learn DBIx::Class faster
• Make your coding easier
point of note
quot;Debugging is twice as hard as writing the code in the first place.
Therefore, if you write the code as cleverly as possible, you are, by
definition, not smart enough to debug it.quot; - Brian W. Kernighan


   This talk is about making it easy so we you are less
   likely to get confused
table setup
example...

Books




Authors
authors table

CREATE TABLE authors(

 id     int(8) primary key auto_increment,

 name   varchar(255)

) engine = InnoDB DEFAULT CHARSET=utf8;
tips

Name tables as simple plurals (add an S) -
makes relationships easier to understand
(issue: Matt Trout quot;Tables should not be plural as gives you plurals for Result::
package names which represent a single rowquot; - talk may be rewritten in future
to reflect this as this is better once you understand the relationship setup -
either way, consistency is important)


Use a character set (UTF8) from the start
(for international characters)
authors table

CREATE TABLE author   s(
 id     int(8) primary key auto_increment,

 name   varchar(255)

) engine =   InnoDB   DEFAULT CHARSET=   utf8;
books table
CREATE TABLE books(

 id      int(8) primary key auto_increment,

 title   varchar(255),

 author int(8),

 foreign key (author)

             references authors(id)

) engine = InnoDB DEFAULT CHARSET=utf8;
tips


Name link fields as singular


Check foreign key is the same field type and
size in both tables
books table
CREATE TABLE books(
 id      int(8) primary key auto_increment,
 title   varchar(255),
 author int(8),

 foreign key (   author)
             references   authors(id)
) engine = InnoDB DEFAULT CHARSET=utf8;
CRUD compared
    C - Create
    R - Retrieve
    U - Update
    D - Delete
Manual (SQL)
manual: create
my $sth = $dbh->prepare('
 INSERT INTO books
 (title, author)
 values (?,?)
');


$sth->execute(
   'A book title',$author_id
);
manual: create
my $sth = $dbh->prepare('
 INSERT INTO books
 (title, author)
 values (?,?)
');


$sth->execute(
     'A book title',   $author_id
);
manual: retrieve
my $sth = $dbh->prepare('
  SELECT title,
  authors.name as author_name
  FROM books, authors
  WHERE books.author = authors.id
');
manual: retrieve
while( my $book = $sth->fetchrow_hashref() )
{
    print 'Author of '
        . $book->{title}
       . ' is '
       . $book->{author_name}
       . quot;nquot;;
}
manual: update
my $update = $dbh->prepare('
 UPDATE books
 SET title = ?
 WHERE id = ?
');


$update->execute(
  'New title',   $book_id);
manual: delete
my $delete = $dbh->prepare('
 DELETE FROM books
 WHERE id = ?
');


$delete->execute(   $book_id);
DBIx::Class
DBIC: create
my $book = $book_model->create({
 title => 'A book title',
 author => $author_id,
});

Look ma, no SQL!

Tip: do not pass in primary_key field, even if its empty/undef as the
object returned will have an empty id, even if your field is auto
increment.
DBIC: create
my $book = $book_model->create({
 title => 'A book title',

 author =>   $author_id,
});
DBIC: create
my $pratchett = $author_model->create({
  name => 'Terry Pratchett',
});
DBIC: create
my $book = $pratchett->create_related(
  'books', {
      title => 'Another Discworld book',
});
or
my $book = $pratchett->add_to_books({
      title => 'Another Discworld book',
});
DBIC: create
my $book = $pratchett->create_related(
  'books', {
      title => 'Another Discworld book',
});
or
my $book = $pratchett->add_to_books({
      title => 'Another Discworld book',
});
DBIC: retrieve

DBIx::Class - Lots of ways to do the same thing...

quot;There is more than one way to do it (TIMTOWTDI,
usually pronounced quot;Tim Toadyquot;) is a Perl mottoquot;
DBIC: retrieve
my $book = $book_model->find($book_id);


my $book = $book_model->search({
 title => 'A book title',
})->single();


my @books = $book_model->search({
 author => $author_id,
})->all();
DBIC: retrieve
while( my $book = $books_rs->next() ) {
    print 'Author of '
        . $book->title()
       . ' is '
       . $book->author()->name()
       . quot;nquot;;
}
DBIC: retrieve
my $books_rs = $book_model->search({
 author => $author_id,
});




Search takes SQL::Abstract formatted queries
> perldoc SQL::Abstract
DBIC: update
$book->update({
  title => 'New title',
});
DBIC: delete
$book->delete();
Creating models
DBIx::Class beginners
DBIx::Class beginners
too much
   typing!

  too much
maintenance!
Schema::Loader



                       Tip


         LPW::DBIC::Result::XX
         LPW::DBIC::ResultSet::XX
splitting logic
      cleanly

LPW::DBIC::Result::XXX     = an individual row

LPW::DBIC::ResultSet::XXX = searches / results
using your Schema
DEBUGGING
DBIC_TRACE=1 ./your_script.pl
Schema::Loader
LPW::DBIC::Result::Authors->table(quot;authorsquot;);
LPW::DBIC::Result::Authors->add_columns(
   quot;idquot;,
   { data_type => quot;INTquot;, default_value => undef,
      is_nullable => 0, size => 8 },
   quot;titlequot;,
   {
      data_type => quot;VARCHARquot;,
      default_value => undef,
      is_nullable => 1,
      size => 255,
   },
);
LPW::DBIC::Result::Authors->set_primary_key(quot;idquot;);
Schema::Loader
LPW::DBIC::Result::Books->table(quot;booksquot;);
LPW::DBIC::Result::Books->add_columns(
   quot;idquot;,
   { data_type => quot;INTquot;, default_value => undef,
      is_nullable => 0, size => 8 },
   quot;namequot;,
   {
      data_type => quot;VARCHARquot;,
      default_value => undef,
      is_nullable => 1,
      size => 255,
   },
   quot;authorquot;,
   { data_type => quot;INTquot;, default_value => undef,
      is_nullable => 1, size => 8 },
);
LPW::DBIC::Result::Books->set_primary_key(quot;idquot;);
Schema::Loader
LPW::DBIC::Result::Authors->has_many(quot;booksquot;, quot;LPW::DBIC::Booksquot;,
{ quot;foreign.authorquot; => quot;self.idquot; });

LPW::DBIC::Result::Books->belongs_to(quot;authorquot;,
quot;LPW::DBIC::Authorsquot;, { id => quot;authorquot; });
Schema::Loader
SQL - debugging

INSERT INTO authors (name)
      VALUES (?): 'Douglas Adams'


INSERT INTO books (author, title)
      VALUES (?, ?): '5', '42'
overloading

LPW::DBIC::Result::Books
LPW:: DBIC::ResultSet::Books
LPW:: DBIC::Result::Authors
LPW:: DBIC::ResultSet::Authors
Result::
package LPW::DBIC::Result::Books;
use base 'DBIx::Class';

use strict;
use warnings;

sub isbn {
  my $self = shift;

    # search amazon or something
    my $api = Amazon::API->book({
         title => $self->title()
    });

    return $api->isbn();
}

1;
Result::
package LPW::DBIC::Result::Books;
use base 'DBIx::Class';

use strict;
use warnings;

sub isbn {
  my $self = shift;

    # search amazon or something
    my $api = Amazon::API->book({
         title => $self->title()
    });

    return $api->isbn();
}

1;
Result::
print $book->isbn();
Result:: (inflating)
package LPW::DBIC::Result::Books;
use base 'DBIx::Class';

use strict;
use warnings;
use DateTime::Format::MySQL;

__PACKAGE__->inflate_column(
    'date_published',
    {   inflate => sub {
            DateTime::Format::MySQL->parse_date(shift);
        },
        deflate => sub {
            shift->ymd();
        },
    }
);
# Automatic see: DBIx::Class::InflateColumn::DateTime
Result:: (inflating)
package LPW::DBIC::Result::Books;
use base 'DBIx::Class';

use strict;
use warnings;
use DateTime::Format::MySQL;

__PACKAGE__->inflate_column(
    'date_published',
    {   inflate => sub {
            DateTime::Format::MySQL->parse_date(shift);
        },
        deflate => sub {
            shift->ymd();
        },
    }
);
# Automatic see: DBIx::Class::InflateColumn::DateTime
Result:: (deflating)
$book->date_published(DateTime->now);

$book->update();




                                        2008-11-29
Result:: (inflating)
my $date_published = $book->date_published()
print $date_published->month_abbr();




                Nov
ResultSets::
package LPW::DBIC::ResultSet::Books;
use base 'DBIx::Class::ResultSet';

sub the_ultimate_books {
    my $self = shift;

     return $self->search(
         {   title => {
                 'like', '%42%'
         }
     });
}

sub by_author {
    my ( $self, $author ) = @_;

     return $self->search( { author => $author->id(), } );
}

1;
ResultSets::
package LPW::DBIC::ResultSet::Books;
use base 'DBIx::Class::ResultSet';
sub the_ultimate_books {
    my $self = shift;

        return $self->search(
            {   title => {
                    'like', '%42%'
            }
        });
}

sub by_author {
    my ( $self, $author ) = @_;

    return $self->search( { author => $author->id(), } );
}
ResultSets::
package LPW::DBIC::ResultSet::Books;
use base 'DBIx::Class::ResultSet';

sub the_ultimate_books {
    my $self = shift;

    return $self->search(
        {   title => {
                'like', '%42%'
        }
    });
}


sub by_author {
    my ( $self, $author ) = @_;

      return $self->search( {
        author => $author->id(),
     } );
}
ResultSets::
use LPW::DBIC;

my $book_model   = LPW::DBIC->resultset('Books');

my $book_rs      = $book_model->the_ultimate_books();

my @books        = $book_rs->all();
ResultSets::chaining
use LPW::DBIC;

my $book_model   = LPW::DBIC->resultset('Books');
my $author_model = LPW::DBIC->resultset('Authors');

my $author = $author_model->search({
        name => 'Douglas Adams',
})->single();

my $book_rs = $book_model->the_ultimate_books()
                         ->by_author($author);

my @books = $book_rs->all();
ResultSets::chaining
my $book_rs = $book_model
               ->the_ultimate_books()
               ->by_author($author);
or

my $book_rs = $book_model
                ->the_ultimate_books();
$book_rs = $book_rs->by_author($author);
# Debug (SQL):

# SELECT me.id, me.title, me.date_published, me.author
#   FROM books me
#   WHERE ( ( ( author = ? ) AND ( title LIKE ? ) ) ): '5', '%42%'
ResultSets::chaining
my $rs = $book_model
            ->category('childrens')
            ->by_author($author)
            ->published_after('1812')
            ->first_page_contains('once upon')
            ->rating_greater_than(4);

my @books = $rs->all();
overloading before
    new record
overloading before
        new record
package LPW::DBIC::Result::Authors;
use base 'DBIx::Class';

sub new {
    my ( $class, $attrs ) = @_;

     # Mess with $attrs

     my $new = $class->next::method($attrs);
     return $new;
}

1;
relationships
multiple authors
a few relationships
     has_many                has_many

Authors         Authors_and_Books       Books


    belongs_to             belongs_to

            many_to_many
a few relationships



        !
new join table
CREATE TABLE author_and_books(
    id      int(8)    primary key auto_increment,
    book 
 int(8),
    author int(8),

    foreign key (book)     references books(id),
    foreign key (author)   references authors(id)

) engine = InnoDB DEFAULT CHARSET=utf8;


ALTER TABLE `books` DROP `author`
new join table
CREATE TABLE author_and_books(
    id      int(8)    primary key auto_increment,
    book 
 int(8),
    author int(8),

    foreign key (book)     references books(id),
    foreign key (author)   references authors(id)

) engine = InnoDB DEFAULT CHARSET=utf8;
has_many
        has_many


Books           Authors_and_Books




        belongs_to
has_many
package LPW::DBIC::Result::Books;

__PACKAGE__->has_many(

     quot;author_and_booksquot;,

     quot;LPW::DBIC::Result::AuthorAndBooksquot;,

     { quot;foreign.bookquot; => quot;self.idquot; },


);

# This is auto generated by Schema::Loader
has_many
package LPW::DBIC::Result::Books;

__PACKAGE__->has_many(

     quot;author_and_booksquot;,
        # Name of accessor
     quot;LPW::DBIC::Result::AuthorAndBooksquot;,
        # Related class
     { quot;foreign.bookquot; => quot;self.idquot; },
        # Relationship (magic often works if not
        # specified, but avoid!)
);
belongs_to
        has_many


Books           Authors_and_Books




        belongs_to
belongs_to
package LPW::DBIC::Result::AuthorAndBooks;


__PACKAGE__->belongs_to(
    quot;bookquot;,
    quot;LPW::DBIC::Result::Booksquot;,
    { id => quot;bookquot; }
);

# This is auto generated by Schema::Loader
belongs_to
package LPW::DBIC::Result::AuthorAndBooks;


__PACKAGE__->belongs_to(
    quot;bookquot;,                     # Accessor name
    quot;LPW::DBIC::Result::Booksquot;, # Related class
    { id => quot;bookquot; }            # Relationship
);
same for Authors

     has_many

Authors         Authors_and_Books



    belongs_to
with no coding...

     has_many                has_many

Authors         Authors_and_Books       Books


    belongs_to             belongs_to
many_to_many

     has_many                has_many

Authors         Authors_and_Books       Books


    belongs_to             belongs_to

            many_to_many
many_to_many
package LPW::DBIC::Result::Books;
use base 'DBIx::Class';

__PACKAGE__->many_to_many(
    quot;authorsquot;

        => quot;author_and_booksquot;,

     'author'
);

1;

# This is   NOT   auto generated by Schema::Loader
many_to_many
package LPW::DBIC::Result::Books;
use base 'DBIx::Class';

__PACKAGE__->many_to_many(
    quot;authorsquot;
    # Accessor Name
        => quot;author_and_booksquot;,
        # has_many accessor_name
    'author'
    # foreign relationship name
);

1;
many_to_many
package LPW::DBIC::Result::Authors;
use base 'DBIx::Class';

__PACKAGE__->many_to_many(
    quot;booksquot;
    # Accessor Name
        => quot;author_and_booksquot;,
        # has_many accessor_name
    'book'
    # foreign relationship name
);

1;

# This is   NOT   auto generated by Schema::Loader
using many_to_many
#!/usr/bin/perl

use LPW::DBIC;

my $author_model = LPW::DBIC->resultset('Authors');

my $author = $author_model->search({
  name => 'Douglas Adams',
})->single();

$author->add_to_books({
  title => 'A new book',
});
using many_to_many
my $author = $author_model->search({
  name => 'Douglas Adams',
})->single();

$author->add_to_books({
  title => 'A new book',
});

# SELECT me.id, me.name FROM authors me
#     WHERE ( name = ? ): 'Douglas Adams';

# INSERT INTO books (title) VALUES (?): 'A new book';

# INSERT INTO author_and_books (author, book)
#     VALUES (?, ?): '5', '2';
using many_to_many
$author->add_to_books($book);


$book->add_to_authors($author_1);

$book->add_to_authors($author_2);
in 16 lines of code
     has_many                has_many

Authors         Authors_and_Books       Books


    belongs_to             belongs_to

            many_to_many
errors


 Read them closely!
error messages
DBIx::Class::Schema::Loader::connection
(): Failed to load external class
definition for
'LPW::DBIC::Result::Authors': Can't
locate object method quot;many_to_manyquot; via
package quot;LPW::DBIC::Result::Authorquot; at
lib/LPW/DBIC/Result/Authors.pm line 9.
Compilation failed in require at /
Library/Perl/5.8.8/DBIx/Class/Schema/
Loader/Base.pm line 292.
error messages
DBIx::Class::Schema::Loader::connection
(): Failed to load external class
definition for
'LPW::DBIC::Result::Authors': Can't
locate object method quot;many_to_manyquot; via
package quot;LPW::DBIC::Result::Authorquot; at
lib/LPW/DBIC/Result/Authors.pm line 9.
Compilation failed in require at /
Library/Perl/5.8.8/DBIx/Class/Schema/
Loader/Base.pm line 292.
errors

• Turn on debugging
• Read error messages (sometimes useful!)
• Check field names
• Check package names
• Check which database you are connected
  to (development/test/live?) - repeat above
thanks

http://leo.cuckoo.org/projects/

    Time for bonus slides?
Template Toolkit


• [% author.books.count %] not working?
• TT all methods are called in list context
• [% author.books_rs.count %] scalar context
        Available for all relationships
Catalyst
package Your::App::Model::LPW;
use base qw(Catalyst::Model::DBIC::Schema);

use strict;
use warnings;

__PACKAGE__->config(
   schema_class => 'LPW::DBIC',
);

1;
Catalyst
package Your::App::Model::LPW;
use base qw(Catalyst::Model::DBIC::Schema);

use strict;
use warnings;

__PACKAGE__->config(
   schema_class => 'LPW::DBIC',
);

1;



            Keep your Scheme in a separate
          package to your Catalyst application
Catalyst
sub action_name : Local {
  my ($self, $c) = @_;

     my $model = $c->model('DBIC::LPW');
     my $author_model = $model->resultset('Authors');

}

1;
thanks!


http://leo.cuckoo.org/projects/
1 of 95

Recommended

Introduction To Catalyst - Part 1 by
Introduction To Catalyst - Part 1Introduction To Catalyst - Part 1
Introduction To Catalyst - Part 1Dan Dascalescu
12K views10 slides
Introduction to Perl - Day 2 by
Introduction to Perl - Day 2Introduction to Perl - Day 2
Introduction to Perl - Day 2Dave Cross
18.9K views160 slides
Database Programming with Perl and DBIx::Class by
Database Programming with Perl and DBIx::ClassDatabase Programming with Perl and DBIx::Class
Database Programming with Perl and DBIx::ClassDave Cross
14.7K views188 slides
Introducing Modern Perl by
Introducing Modern PerlIntroducing Modern Perl
Introducing Modern PerlDave Cross
30.4K views161 slides
Intro ProxySQL by
Intro ProxySQLIntro ProxySQL
Intro ProxySQLI Goo Lee
1.7K views38 slides
Open Source 101 2022 - MySQL Indexes and Histograms by
Open Source 101 2022 - MySQL Indexes and HistogramsOpen Source 101 2022 - MySQL Indexes and Histograms
Open Source 101 2022 - MySQL Indexes and HistogramsFrederic Descamps
358 views185 slides

More Related Content

What's hot

Label based Mandatory Access Control on PostgreSQL by
Label based Mandatory Access Control on PostgreSQLLabel based Mandatory Access Control on PostgreSQL
Label based Mandatory Access Control on PostgreSQLKohei KaiGai
5K views29 slides
Elasticsearch From the Bottom Up by
Elasticsearch From the Bottom UpElasticsearch From the Bottom Up
Elasticsearch From the Bottom Upfoundsearch
6K views82 slides
Basic perl programming by
Basic perl programmingBasic perl programming
Basic perl programmingThang Nguyen
627 views27 slides
MongoDB Aggregation Framework by
MongoDB Aggregation FrameworkMongoDB Aggregation Framework
MongoDB Aggregation FrameworkCaserta
7.8K views33 slides
Introduction to Perl by
Introduction to PerlIntroduction to Perl
Introduction to PerlDave Cross
3.3K views152 slides
You code sucks, let's fix it by
You code sucks, let's fix itYou code sucks, let's fix it
You code sucks, let's fix itRafael Dohms
56.4K views56 slides

What's hot(20)

Label based Mandatory Access Control on PostgreSQL by Kohei KaiGai
Label based Mandatory Access Control on PostgreSQLLabel based Mandatory Access Control on PostgreSQL
Label based Mandatory Access Control on PostgreSQL
Kohei KaiGai5K views
Elasticsearch From the Bottom Up by foundsearch
Elasticsearch From the Bottom UpElasticsearch From the Bottom Up
Elasticsearch From the Bottom Up
foundsearch6K views
Basic perl programming by Thang Nguyen
Basic perl programmingBasic perl programming
Basic perl programming
Thang Nguyen627 views
MongoDB Aggregation Framework by Caserta
MongoDB Aggregation FrameworkMongoDB Aggregation Framework
MongoDB Aggregation Framework
Caserta 7.8K views
Introduction to Perl by Dave Cross
Introduction to PerlIntroduction to Perl
Introduction to Perl
Dave Cross3.3K views
You code sucks, let's fix it by Rafael Dohms
You code sucks, let's fix itYou code sucks, let's fix it
You code sucks, let's fix it
Rafael Dohms56.4K views
A Spring Data’s Guide to Persistence by VMware Tanzu
A Spring Data’s Guide to PersistenceA Spring Data’s Guide to Persistence
A Spring Data’s Guide to Persistence
VMware Tanzu480 views
[pgday.Seoul 2022] 서비스개편시 PostgreSQL 도입기 - 진소린 & 김태정 by PgDay.Seoul
[pgday.Seoul 2022] 서비스개편시 PostgreSQL 도입기 - 진소린 & 김태정[pgday.Seoul 2022] 서비스개편시 PostgreSQL 도입기 - 진소린 & 김태정
[pgday.Seoul 2022] 서비스개편시 PostgreSQL 도입기 - 진소린 & 김태정
PgDay.Seoul188 views
ProxySQL for MySQL by Mydbops
ProxySQL for MySQLProxySQL for MySQL
ProxySQL for MySQL
Mydbops4.3K views
Introduction to MongoDB by Mike Dirolf
Introduction to MongoDBIntroduction to MongoDB
Introduction to MongoDB
Mike Dirolf38.4K views
MongoDB - Aggregation Pipeline by Jason Terpko
MongoDB - Aggregation PipelineMongoDB - Aggregation Pipeline
MongoDB - Aggregation Pipeline
Jason Terpko1.2K views
Introduction to Redis by Dvir Volk
Introduction to RedisIntroduction to Redis
Introduction to Redis
Dvir Volk121K views
Ansible with oci by DonghuKIM2
Ansible with ociAnsible with oci
Ansible with oci
DonghuKIM2968 views
The MySQL Query Optimizer Explained Through Optimizer Trace by oysteing
The MySQL Query Optimizer Explained Through Optimizer TraceThe MySQL Query Optimizer Explained Through Optimizer Trace
The MySQL Query Optimizer Explained Through Optimizer Trace
oysteing1K views

Similar to DBIx::Class beginners

DBIx::Class introduction - 2010 by
DBIx::Class introduction - 2010DBIx::Class introduction - 2010
DBIx::Class introduction - 2010leo lapworth
3.7K views98 slides
Introduction To Moco by
Introduction To MocoIntroduction To Moco
Introduction To MocoNaoya Ito
2K views55 slides
Rapid Prototyping with PEAR by
Rapid Prototyping with PEARRapid Prototyping with PEAR
Rapid Prototyping with PEARMarkus Wolff
9.1K views56 slides
DBIx-DataModel v2.0 in detail by
DBIx-DataModel v2.0 in detail DBIx-DataModel v2.0 in detail
DBIx-DataModel v2.0 in detail Laurent Dami
5K views68 slides
Php 102: Out with the Bad, In with the Good by
Php 102: Out with the Bad, In with the GoodPhp 102: Out with the Bad, In with the Good
Php 102: Out with the Bad, In with the GoodJeremy Kendall
3.4K views95 slides
Php Data Objects by
Php Data ObjectsPhp Data Objects
Php Data Objectshiren.joshi
1.7K views19 slides

Similar to DBIx::Class beginners(20)

DBIx::Class introduction - 2010 by leo lapworth
DBIx::Class introduction - 2010DBIx::Class introduction - 2010
DBIx::Class introduction - 2010
leo lapworth3.7K views
Introduction To Moco by Naoya Ito
Introduction To MocoIntroduction To Moco
Introduction To Moco
Naoya Ito2K views
Rapid Prototyping with PEAR by Markus Wolff
Rapid Prototyping with PEARRapid Prototyping with PEAR
Rapid Prototyping with PEAR
Markus Wolff9.1K views
DBIx-DataModel v2.0 in detail by Laurent Dami
DBIx-DataModel v2.0 in detail DBIx-DataModel v2.0 in detail
DBIx-DataModel v2.0 in detail
Laurent Dami5K views
Php 102: Out with the Bad, In with the Good by Jeremy Kendall
Php 102: Out with the Bad, In with the GoodPhp 102: Out with the Bad, In with the Good
Php 102: Out with the Bad, In with the Good
Jeremy Kendall3.4K views
Php Data Objects by hiren.joshi
Php Data ObjectsPhp Data Objects
Php Data Objects
hiren.joshi1.7K views
Neatly Hashing a Tree: FP tree-fold in Perl5 & Perl6 by Workhorse Computing
Neatly Hashing a Tree: FP tree-fold in Perl5 & Perl6Neatly Hashing a Tree: FP tree-fold in Perl5 & Perl6
Neatly Hashing a Tree: FP tree-fold in Perl5 & Perl6
Into to DBI with DBD::Oracle by byterock
Into to DBI with DBD::OracleInto to DBI with DBD::Oracle
Into to DBI with DBD::Oracle
byterock403 views
PHP and Rich Internet Applications by elliando dias
PHP and Rich Internet ApplicationsPHP and Rich Internet Applications
PHP and Rich Internet Applications
elliando dias4K views
Drupal Development (Part 2) by Jeff Eaton
Drupal Development (Part 2)Drupal Development (Part 2)
Drupal Development (Part 2)
Jeff Eaton2.1K views
P H P Part I I, By Kian by phelios
P H P  Part  I I,  By  KianP H P  Part  I I,  By  Kian
P H P Part I I, By Kian
phelios2.7K views
Intro to #memtech PHP 2011-12-05 by Jeremy Kendall
Intro to #memtech PHP   2011-12-05Intro to #memtech PHP   2011-12-05
Intro to #memtech PHP 2011-12-05
Jeremy Kendall1.4K views
Working with databases in Perl by Laurent Dami
Working with databases in PerlWorking with databases in Perl
Working with databases in Perl
Laurent Dami4.6K views
DBIx::Skinnyと仲間たち by Ryo Miyake
DBIx::Skinnyと仲間たちDBIx::Skinnyと仲間たち
DBIx::Skinnyと仲間たち
Ryo Miyake1.9K views
Iterators & generators: practical uses in memory management by Adrian Cardenas
Iterators & generators: practical uses in memory managementIterators & generators: practical uses in memory management
Iterators & generators: practical uses in memory management
Adrian Cardenas139 views
Advanced Perl Techniques by Dave Cross
Advanced Perl TechniquesAdvanced Perl Techniques
Advanced Perl Techniques
Dave Cross7.2K views

Recently uploaded

Uni Systems for Power Platform.pptx by
Uni Systems for Power Platform.pptxUni Systems for Power Platform.pptx
Uni Systems for Power Platform.pptxUni Systems S.M.S.A.
50 views21 slides
AMAZON PRODUCT RESEARCH.pdf by
AMAZON PRODUCT RESEARCH.pdfAMAZON PRODUCT RESEARCH.pdf
AMAZON PRODUCT RESEARCH.pdfJerikkLaureta
15 views13 slides
Melek BEN MAHMOUD.pdf by
Melek BEN MAHMOUD.pdfMelek BEN MAHMOUD.pdf
Melek BEN MAHMOUD.pdfMelekBenMahmoud
14 views1 slide
Empathic Computing: Delivering the Potential of the Metaverse by
Empathic Computing: Delivering  the Potential of the MetaverseEmpathic Computing: Delivering  the Potential of the Metaverse
Empathic Computing: Delivering the Potential of the MetaverseMark Billinghurst
470 views80 slides
AI: mind, matter, meaning, metaphors, being, becoming, life values by
AI: mind, matter, meaning, metaphors, being, becoming, life valuesAI: mind, matter, meaning, metaphors, being, becoming, life values
AI: mind, matter, meaning, metaphors, being, becoming, life valuesTwain Liu 刘秋艳
35 views16 slides
Tunable Laser (1).pptx by
Tunable Laser (1).pptxTunable Laser (1).pptx
Tunable Laser (1).pptxHajira Mahmood
23 views37 slides

Recently uploaded(20)

AMAZON PRODUCT RESEARCH.pdf by JerikkLaureta
AMAZON PRODUCT RESEARCH.pdfAMAZON PRODUCT RESEARCH.pdf
AMAZON PRODUCT RESEARCH.pdf
JerikkLaureta15 views
Empathic Computing: Delivering the Potential of the Metaverse by Mark Billinghurst
Empathic Computing: Delivering  the Potential of the MetaverseEmpathic Computing: Delivering  the Potential of the Metaverse
Empathic Computing: Delivering the Potential of the Metaverse
Mark Billinghurst470 views
AI: mind, matter, meaning, metaphors, being, becoming, life values by Twain Liu 刘秋艳
AI: mind, matter, meaning, metaphors, being, becoming, life valuesAI: mind, matter, meaning, metaphors, being, becoming, life values
AI: mind, matter, meaning, metaphors, being, becoming, life values
Special_edition_innovator_2023.pdf by WillDavies22
Special_edition_innovator_2023.pdfSpecial_edition_innovator_2023.pdf
Special_edition_innovator_2023.pdf
WillDavies2216 views
Beyond the Hype: What Generative AI Means for the Future of Work - Damien Cum... by NUS-ISS
Beyond the Hype: What Generative AI Means for the Future of Work - Damien Cum...Beyond the Hype: What Generative AI Means for the Future of Work - Damien Cum...
Beyond the Hype: What Generative AI Means for the Future of Work - Damien Cum...
NUS-ISS34 views
[2023] Putting the R! in R&D.pdf by Eleanor McHugh
[2023] Putting the R! in R&D.pdf[2023] Putting the R! in R&D.pdf
[2023] Putting the R! in R&D.pdf
Eleanor McHugh38 views
Emerging & Future Technology - How to Prepare for the Next 10 Years of Radica... by NUS-ISS
Emerging & Future Technology - How to Prepare for the Next 10 Years of Radica...Emerging & Future Technology - How to Prepare for the Next 10 Years of Radica...
Emerging & Future Technology - How to Prepare for the Next 10 Years of Radica...
NUS-ISS16 views
Future of Learning - Yap Aye Wee.pdf by NUS-ISS
Future of Learning - Yap Aye Wee.pdfFuture of Learning - Yap Aye Wee.pdf
Future of Learning - Yap Aye Wee.pdf
NUS-ISS41 views
Future of Learning - Khoong Chan Meng by NUS-ISS
Future of Learning - Khoong Chan MengFuture of Learning - Khoong Chan Meng
Future of Learning - Khoong Chan Meng
NUS-ISS33 views
Architecting CX Measurement Frameworks and Ensuring CX Metrics are fit for Pu... by NUS-ISS
Architecting CX Measurement Frameworks and Ensuring CX Metrics are fit for Pu...Architecting CX Measurement Frameworks and Ensuring CX Metrics are fit for Pu...
Architecting CX Measurement Frameworks and Ensuring CX Metrics are fit for Pu...
NUS-ISS37 views
Digital Product-Centric Enterprise and Enterprise Architecture - Tan Eng Tsze by NUS-ISS
Digital Product-Centric Enterprise and Enterprise Architecture - Tan Eng TszeDigital Product-Centric Enterprise and Enterprise Architecture - Tan Eng Tsze
Digital Product-Centric Enterprise and Enterprise Architecture - Tan Eng Tsze
NUS-ISS19 views
Attacking IoT Devices from a Web Perspective - Linux Day by Simone Onofri
Attacking IoT Devices from a Web Perspective - Linux Day Attacking IoT Devices from a Web Perspective - Linux Day
Attacking IoT Devices from a Web Perspective - Linux Day
Simone Onofri15 views
How the World's Leading Independent Automotive Distributor is Reinventing Its... by NUS-ISS
How the World's Leading Independent Automotive Distributor is Reinventing Its...How the World's Leading Independent Automotive Distributor is Reinventing Its...
How the World's Leading Independent Automotive Distributor is Reinventing Its...
NUS-ISS15 views
.conf Go 2023 - How KPN drives Customer Satisfaction on IPTV by Splunk
.conf Go 2023 - How KPN drives Customer Satisfaction on IPTV.conf Go 2023 - How KPN drives Customer Satisfaction on IPTV
.conf Go 2023 - How KPN drives Customer Satisfaction on IPTV
Splunk88 views

DBIx::Class beginners