File Coverage

blib/lib/Relations/Query.pm

Criterion	Covered	Total	%
statement	61	75	81.3
branch	17	18	94.4
condition			n/a
subroutine	10	11	90.9
pod	9	9	100.0
total	97	113	85.8

# This module is for creating complex select queries with
# Relations.

package Relations::Query;
require Exporter;
require Relations;

use Relations;

# You can run this file through either pod2man or pod2html to produce pretty
# documentation in manual or html file format (these utilities are part of the
# Perl 5 distribution).

# Copyright 2001 GAF-3 Industries, Inc. All rights reserved.
# Written by George A. Fitch III (aka Gaffer), [e-mail]

# This program is free software, you can redistribute it and/or modify it under
# the same terms as Perl istelf

# Do the version thing

$Relations::Query::VERSION='0.93';

@ISA = qw(Exporter);

@EXPORT = qw(
  new
  to_string
  to_text
);

@EXPORT_OK = qw(
  new
  clone
  add
  set
  get
  get_add
  get_set
  to_string
  to_text
);

%EXPORT_TAGS = ();

# Be strict

use strict;



### Creates a Relations::Query object. It takes
### info for each part of the query, and stores
### it into the new object.

sub new {

  my ($type) = shift;

  # Get all the arguments passed, which are named
  # for their part of the query.

  my ($select,
      $from,
      $where,
      $group_by,
      $having,
      $order_by,
      $limit) = rearrange(['SELECT',
                           'FROM',
                           'WHERE',
                           'GROUP_BY',
                           'HAVING',
                           'ORDER_BY',
                           'LIMIT'],@_);

  # Create the hash to hold all the vars
  # for this object.

  my $self = {};

  # Bless it with the type sent (I think this
  # makes it a full fledged object)

  bless $self, $type;

  # Add the sent info into the hash

  $self->{'select'} = as_clause($select);
  $self->{'from'} = as_clause($from);
  $self->{'where'} = equals_clause($where);
  $self->{'group_by'} = comma_clause($group_by);
  $self->{'having'} = equals_clause($having);
  $self->{'order_by'} = comma_clause($order_by);
  $self->{'limit'} = comma_clause($limit);

  # Give thyself

  return $self;

}



### Creates a copy of a current query.

sub clone {

  # Get the self reference first

  my ($self) = shift;

  # Create a new query object using this query
  # object's info

  my ($clone) = new Relations::Query($self->{'select'},
                                     $self->{'from'},
                                     $self->{'where'},
                                     $self->{'group_by'},
                                     $self->{'having'},
                                     $self->{'order_by'},
                                     $self->{'limit'});

  # Return the new object

  return $clone;

}



### Gets the query for the object in string form.

sub get {

  # Get the self reference first

  my($self) = shift;

  # Create an array to hold the query pieces

  my @query = ();

  # Add info where appropriate.

  push @query, "select $self->{'select'}"     if length($self->{'select'});
  push @query, "from $self->{'from'}"         if length($self->{'from'});
  push @query, "where $self->{'where'}"       if length($self->{'where'});
  push @query, "group by $self->{'group_by'}" if length($self->{'group_by'});
  push @query, "having $self->{'having'}"     if length($self->{'having'});
  push @query, "order by $self->{'order_by'}" if length($self->{'order_by'});
  push @query, "limit $self->{'limit'}"       if length($self->{'limit'});

  # Return the info, delimitted by a space.

  return join ' ', @query;

}



### Adds data to the existing clauses of the query.

sub add {

  # Get the self reference first

  my ($self) = shift;

  # Get all the other arguments passed

  my ($select,
      $from,
      $where,
      $group_by,
      $having,
      $order_by,
      $limit) = rearrange(['SELECT',
                           'FROM',
                           'WHERE',
                           'GROUP_BY',
                           'HAVING',
                           'ORDER_BY',
                           'LIMIT'],@_);

  # Concatente info into the self hash, prefixing it if there's
  # already something there, only if something's actually been
  # sent.

  $self->{'select'} =   add_as_clause($self->{'select'},$select);
  $self->{'from'} =     add_as_clause($self->{'from'},$from);
  $self->{'where'} =    add_equals_clause($self->{'where'},$where);
  $self->{'group_by'} = add_comma_clause($self->{'group_by'},$group_by);
  $self->{'having'} =   add_equals_clause($self->{'having'},$having);
  $self->{'order_by'} = add_comma_clause($self->{'order_by'},$order_by);
  $self->{'limit'} =    add_comma_clause($self->{'limit'},$limit);

}



### Sets the existing settings of a query.

sub set {

  # Get the self reference first

  my ($self) = shift;

  # Get all the other arguments passed, which
  # are named for their part of the query.

  my ($select,
      $from,
      $where,
      $group_by,
      $having,
      $order_by,
      $limit) = rearrange(['SELECT',
                           'FROM',
                           'WHERE',
                           'GROUP_BY',
                           'HAVING',
                           'ORDER_BY',
                           'LIMIT'],@_);

  # Put info into the self hash, only if something's actually been
  # sent.

  $self->{'select'} =   set_as_clause($self->{'select'},$select);
  $self->{'from'} =     set_as_clause($self->{'from'},$from);
  $self->{'where'} =    set_equals_clause($self->{'where'},$where);
  $self->{'group_by'} = set_comma_clause($self->{'group_by'},$group_by);
  $self->{'having'} =   set_equals_clause($self->{'having'},$having);
  $self->{'order_by'} = set_comma_clause($self->{'order_by'},$order_by);
  $self->{'limit'} =    set_comma_clause($self->{'limit'},$limit);

}



### Gets the string form of the query object, and accepts
### extra info to temporarily add on to the current
### clause. The added info will be in the returned string,
### but will not be stored in the query object.

sub get_add {

  # Get the self reference first

  my ($self) = shift;

  # Create a clone of ourselves

  my ($get_add) = $self->clone();

  # Add the stuff sent to our clone

  $get_add->add(@_);

  # Return our fattened clone's query

  return $get_add->get();

}



### Gets the string form of the query object, and accepts
### extra info to temporarily overwrite the current
### clause. The set info will be in the returned string,
### but will not be stored in the query object.

sub get_set {

  # Get the self reference first

  my ($self) = shift;

  # Create a clone of ourselves

  my ($get_set) = $self->clone();

  # Set the stuff sent to our clone

  $get_set->set(@_);

  # Return our altered clone's query

  return $get_set->get();

}



### Takes a hash ref, Relations::Query object, or string
### and returns a string.

sub to_string {

  # Get the query sent

  my ($query) = shift;

  # If we were sent a hash reference, create a new
  # Relations::Query object.

  $query = new Relations::Query($query) if ref($query) eq 'HASH';

  # If we were sent a query object, get the query
  # string from it.

  $query = $query->get() if ref($query) eq 'Relations::Query';

  # Return the query string

  return $query;

}



### Returns text info about the Relations::Query
### object. Useful for debugging and export purposes.

sub to_text {

  # Know thyself

  my ($self) = shift;

  # Get the indenting string and current
  # indenting amount.

  my ($string,$current) = @_;

  # Calculate the ident amount so we don't
  # do it a bazillion times.

  my $indent = ($string x $current);

  # Create a text string to hold everything

  my $text = '';

  # 411

  $text .= $indent . "Relations::Query: $self\n\n";
  $text .= $indent . "Select: $self->{select}\n";
  $text .= $indent . "From: $self->{from}\n";
  $text .= $indent . "Where: $self->{where}\n";
  $text .= $indent . "Group By: $self->{group_by}\n";
  $text .= $indent . "Having: $self->{having}\n";
  $text .= $indent . "Order By: $self->{order_by}\n";
  $text .= $indent . "Limit: $self->{limit}\n";

  $text .= "\n";

  # Return the text

  return $text;

}

$Relations::Query::VERSION;

__END__