| 1 | #!/usr/bin/perl | ||
| 2 | ############################################################################### | ||
| 3 | # | ||
| 4 | # @file API/Eulerian/EDW/Sql/Builder.pm | ||
| 5 | # | ||
| 6 | # @brief Eulerian Data Warehouse SQL Builder class definition. | ||
| 7 | # | ||
| 8 | # @author x.thorillon@eulerian.com | ||
| 9 | # | ||
| 10 | # @date 27/01/2016 | ||
| 11 | # | ||
| 12 | ############################################################################### | ||
| 13 | # | ||
| 14 | # Enforce compilor rules | ||
| 15 | # | ||
| 16 | use strict; use warnings; | ||
| 17 | # | ||
| 18 | # Set Package Name | ||
| 19 | # | ||
| 20 | package API::Eulerian::EDW::Sql::Builder; | ||
| 21 | # | ||
| 22 | # Load Sql modules. | ||
| 23 | # | ||
| 24 | use API::Eulerian::EDW::Sql::Timerange; | ||
| 25 | use API::Eulerian::EDW::Sql::Reader; | ||
| 26 | use API::Eulerian::EDW::Sql::Group; | ||
| 27 | use API::Eulerian::EDW::Sql::Join; | ||
| 28 | use API::Eulerian::EDW::Sql::Alias; | ||
| 29 | use API::Eulerian::EDW::Sql::Array; | ||
| 30 | use API::Eulerian::EDW::Sql::Outputs; | ||
| 31 | use API::Eulerian::EDW::Sql::Then; | ||
| 32 | # | ||
| 33 | # @brief Map of Eulerian Data Warehouse Analytics Analysis outputs mode. | ||
| 34 | # | ||
| 35 | use constant OUTPUTS => sub { { | ||
| 36 | ROW => 'OUTPUTS_ROW', | ||
| 37 | DISTINCT => 'OUTPUTS_DISTINCT', | ||
| 38 | PIVOT => 'OUTPUTS_PIVOT', | ||
| 39 | }->{ +shift } }; | ||
| 40 | # | ||
| 41 | # @brief Allocate and initialize a new API Eulerian Data Warehouse Sql | ||
| 42 | # Builder instance. | ||
| 43 | # | ||
| 44 | # @param $proto - Class name. | ||
| 45 | # @param $setup - Initial setup values ( unused ). | ||
| 46 | # | ||
| 47 | # @return SQL Builder instance. | ||
| 48 | # | ||
| 49 | sub new | ||
| 50 | { | ||
| 51 | my $proto = shift; | ||
| 52 | my $class = ref( $proto ) || $proto; | ||
| 53 | my $setup = shift || {}; | ||
| 54 | return bless( { | ||
| 55 | timerange => new API::Eulerian::EDW::Sql::Timerange(), | ||
| 56 | readers => new API::Eulerian::EDW::Sql::Array( { sep => ' ' } ), | ||
| 57 | groups => new API::Eulerian::EDW::Sql::Array(), | ||
| 58 | joins => new API::Eulerian::EDW::Sql::Array(), | ||
| 59 | aliases => new API::Eulerian::EDW::Sql::Array( { sep => ', ' } ), | ||
| 60 | thens => new API::Eulerian::EDW::Sql::Array(), | ||
| 61 | outputs => new API::Eulerian::EDW::Sql::Outputs(), | ||
| 62 | }, | ||
| 63 | ); | ||
| 64 | } | ||
| 65 | # | ||
| 66 | # @brief Setup Eulerian Data Warehouse Sql Timerange. | ||
| 67 | # | ||
| 68 | # @param $self - Sql builder. | ||
| 69 | # @param $begin - Timerange begin. | ||
| 70 | # @param $end - Timerange end. | ||
| 71 | # | ||
| 72 | # @return 0 - Success. | ||
| 73 | # | ||
| 74 | sub timerange | ||
| 75 | { | ||
| 76 | my ( $self, $begin, $end ) = @_; | ||
| 77 | my $timerange = $self->{ timerange }; | ||
| 78 | |||
| 79 | $timerange->begin( $begin ); | ||
| 80 | $timerange->end( $end ); | ||
| 81 | |||
| 82 | return $timerange->valid(); | ||
| 83 | } | ||
| 84 | # | ||
| 85 | # @brief Add reader. | ||
| 86 | # | ||
| 87 | # @param $self - Sql builder. | ||
| 88 | # @param $name - Reader name. | ||
| 89 | # @param $path - Reader path ( ie : <store>:<object> ). | ||
| 90 | # @param $site - Site. | ||
| 91 | # @param $filter - Objects filter. | ||
| 92 | # | ||
| 93 | # @return Readers count. | ||
| 94 | # | ||
| 95 | sub readers | ||
| 96 | { | ||
| 97 | my ( $self, $name, $path, $site, $filter ) = @_; | ||
| 98 | my $readers = $self->{ readers }; | ||
| 99 | |||
| 100 | if( ! ( defined( $name ) && defined( $path ) && defined( $site ) ) ) { | ||
| 101 | die( 'Adding reader failed, mandatory argument is missing' ); | ||
| 102 | } | ||
| 103 | |||
| 104 | $readers->push( | ||
| 105 | new API::Eulerian::EDW::Sql::Reader( { | ||
| 106 | name => $name, | ||
| 107 | path => $path, | ||
| 108 | site => $site, | ||
| 109 | filter => $filter, | ||
| 110 | } ) | ||
| 111 | ); | ||
| 112 | |||
| 113 | return $readers->count(); | ||
| 114 | } | ||
| 115 | # | ||
| 116 | # @brief Add group. | ||
| 117 | # | ||
| 118 | # @param $self - Sql builder. | ||
| 119 | # @param $name - Group name. | ||
| 120 | # @param $with - Source of the group. | ||
| 121 | # @param $filter - Group filtering. | ||
| 122 | # | ||
| 123 | # @return Groups count. | ||
| 124 | # | ||
| 125 | sub groups | ||
| 126 | { | ||
| 127 | my ( $self, $name, $with, $filter ) = @_; | ||
| 128 | my $groups = $self->{ groups }; | ||
| 129 | |||
| 130 | if( ! ( defined( $name ) && defined( $with ) ) ) { | ||
| 131 | die( 'Adding group failed, mandatory argument is missing' ); | ||
| 132 | } | ||
| 133 | |||
| 134 | $groups->push( | ||
| 135 | new API::Eulerian::EDW::Sql::Group( { | ||
| 136 | name => $name, | ||
| 137 | with => $with, | ||
| 138 | filter => $filter, | ||
| 139 | } ) | ||
| 140 | ); | ||
| 141 | |||
| 142 | return $groups->count(); | ||
| 143 | } | ||
| 144 | # | ||
| 145 | # @brief Add join. | ||
| 146 | # | ||
| 147 | # @param $self - Sql builder. | ||
| 148 | # @param $name - Group name. | ||
| 149 | # @param $left - Left data source. | ||
| 150 | # @param $right - Right data source. | ||
| 151 | # @param $criteria - Join criteria. | ||
| 152 | # | ||
| 153 | # @return Joins count. | ||
| 154 | # | ||
| 155 | sub joins | ||
| 156 | { | ||
| 157 | my ( $self, $name, $left, $right, $filter ) = @_; | ||
| 158 | my $joins = $self->{ joins }; | ||
| 159 | |||
| 160 | if( ! ( defined( $name ) && defined( $left ) && defined( $right ) ) ) { | ||
| 161 | die( 'Adding join failed, mandatory argument is missing' ); | ||
| 162 | } | ||
| 163 | |||
| 164 | $joins->push( | ||
| 165 | new API::Eulerian::EDW::Sql::Join( { | ||
| 166 | name => $name, | ||
| 167 | left => $left, | ||
| 168 | right => $right, | ||
| 169 | filter => $filter, | ||
| 170 | } ) | ||
| 171 | ); | ||
| 172 | |||
| 173 | return $joins->count(); | ||
| 174 | } | ||
| 175 | # | ||
| 176 | # @brief Add alias. | ||
| 177 | # | ||
| 178 | # @param $self - Sql builder. | ||
| 179 | # @param $name - Alias name. | ||
| 180 | # @param $formula - Alias formula. | ||
| 181 | # | ||
| 182 | # @return Aliases count. | ||
| 183 | # | ||
| 184 | sub aliases | ||
| 185 | { | ||
| 186 | my ( $self, $name, $formula ) = @_; | ||
| 187 | my $aliases = $self->{ aliases }; | ||
| 188 | |||
| 189 | if( ! ( defined( $name ) && defined( $formula ) ) ) { | ||
| 190 | die( 'Adding alias failed, mandatory argument is missing' ); | ||
| 191 | } | ||
| 192 | |||
| 193 | $aliases->push( | ||
| 194 | new API::Eulerian::EDW::Sql::Alias( { | ||
| 195 | name => $name, | ||
| 196 | formula => $formula | ||
| 197 | } ) | ||
| 198 | ); | ||
| 199 | |||
| 200 | return $aliases->count(); | ||
| 201 | } | ||
| 202 | # | ||
| 203 | # @brief Add then. | ||
| 204 | # | ||
| 205 | # @param $self - Sql builder. | ||
| 206 | # @param $formula - Then formula. | ||
| 207 | # | ||
| 208 | # @return Thens formulas count. | ||
| 209 | # | ||
| 210 | sub thens | ||
| 211 | { | ||
| 212 | my ( $self, $formula ) = @_; | ||
| 213 | my $thens = $self->{ thens }; | ||
| 214 | |||
| 215 | if( ! defined( $formula ) ) { | ||
| 216 | die( 'Adding then failed, mandatory argument is missing' ); | ||
| 217 | } | ||
| 218 | |||
| 219 | $thens->push( | ||
| 220 | new API::Eulerian::EDW::Sql::Then( { | ||
| 221 | formula => $formula | ||
| 222 | } ) | ||
| 223 | ); | ||
| 224 | |||
| 225 | return $thens->count(); | ||
| 226 | } | ||
| 227 | # | ||
| 228 | # @brief Setup Eulerian Data Warehouse Analytics Analysis outputs master. | ||
| 229 | # | ||
| 230 | # @param $self - Sql builder. | ||
| 231 | # @param $name - Master outputs name. | ||
| 232 | # | ||
| 233 | # @return Master name. | ||
| 234 | # | ||
| 235 | sub master | ||
| 236 | { | ||
| 237 | my ( $self, $name ) = @_; | ||
| 238 | my $outputs = $self->{ outputs }; | ||
| 239 | $outputs->master( $name ); | ||
| 240 | return $name; | ||
| 241 | } | ||
| 242 | # | ||
| 243 | # @brief Setup Eulerian Data Warehouse Analytics Analytics outputs mode. | ||
| 244 | # | ||
| 245 | # @param $self - Sql builder. | ||
| 246 | # @param $mode - Master outputs mode. | ||
| 247 | # | ||
| 248 | # @return Master name. | ||
| 249 | # | ||
| 250 | sub mode | ||
| 251 | { | ||
| 252 | my ( $self, $mode ) = @_; | ||
| 253 | my $outputs = $self->{ outputs }; | ||
| 254 | $outputs->mode( OUTPUTS->( $mode ) ); | ||
| 255 | return $outputs->mode(); | ||
| 256 | } | ||
| 257 | # | ||
| 258 | # @brief Setup Eulerian Data Warehouse Analytics Analysis outputs filter. | ||
| 259 | # | ||
| 260 | # @param $self - Sql builder. | ||
| 261 | # @param $formula - Filter formula. | ||
| 262 | # | ||
| 263 | # @return Filter. | ||
| 264 | # | ||
| 265 | sub filter | ||
| 266 | { | ||
| 267 | my ( $self, $formula ) = @_; | ||
| 268 | my $outputs = $self->{ outputs }; | ||
| 269 | $outputs->filter( $formula ); | ||
| 270 | return $outputs->filter(); | ||
| 271 | } | ||
| 272 | # | ||
| 273 | # @brief Add output to Eulerian Data Warehouse Analytics Analysis outputs. | ||
| 274 | # | ||
| 275 | # @param $self - Sql builder. | ||
| 276 | # @param $formula - Output formula | ||
| 277 | # | ||
| 278 | # @return Count of outputs. | ||
| 279 | # | ||
| 280 | sub outputs | ||
| 281 | { | ||
| 282 | my ( $self, $formula ) = @_; | ||
| 283 | my $outputs = $self->{ outputs }; | ||
| 284 | return $outputs->add( $formula ); | ||
| 285 | } | ||
| 286 | # | ||
| 287 | # @brief Stringify Sql request. | ||
| 288 | # | ||
| 289 | # @param $self - Sql builder. | ||
| 290 | # | ||
| 291 | # @return Stringified Sql request. | ||
| 292 | # | ||
| 293 | sub str | ||
| 294 | { | ||
| 295 | my $self = shift; | ||
| 296 | my $timerange = $self->{ timerange }; | ||
| 297 | my $aliases = $self->{ aliases }; | ||
| 298 | my $readers = $self->{ readers }; | ||
| 299 | my $outputs = $self->{ outputs }; | ||
| 300 | my $groups = $self->{ groups }; | ||
| 301 | my $joins = $self->{ joins }; | ||
| 302 | my $thens = $self->{ thens }; | ||
| 303 | my $str = ''; | ||
| 304 | my $mode; | ||
| 305 | |||
| 306 | $str .= "GET { "; | ||
| 307 | $str .= $timerange->str(); | ||
| 308 | if( $readers->count() ) { | ||
| 309 | $str .= " READERS { "; | ||
| 310 | $str .= $readers->str(); | ||
| 311 | $str .= " } "; | ||
| 312 | } | ||
| 313 | if( $groups->count() ) { | ||
| 314 | $str .= "GROUPS { "; | ||
| 315 | $str .= $groups->str(); | ||
| 316 | $str .= " } "; | ||
| 317 | } | ||
| 318 | if( $joins->count() ) { | ||
| 319 | $str .= "JOINS { "; | ||
| 320 | $str .= $joins->str(); | ||
| 321 | $str .= " } "; | ||
| 322 | } | ||
| 323 | if( $aliases->count() ) { | ||
| 324 | $str .= "ALIASES { "; | ||
| 325 | $str .= $aliases->str(); | ||
| 326 | $str .= " } "; | ||
| 327 | } | ||
| 328 | $str .= $outputs->str(); | ||
| 329 | if( $thens->count() ) { | ||
| 330 | $str .= "THEN { "; | ||
| 331 | $str .= $thens->str(); | ||
| 332 | $str .= " } "; | ||
| 333 | } | ||
| 334 | $str .= "};"; | ||
| 335 | |||
| 336 | return $str; | ||
| 337 | } | ||
| 338 | # | ||
| 339 | # End up module properly | ||
| 340 | # | ||
| 341 | 1; | ||
| 342 | |||
| 343 | __END__ |