sportdb-catalogs 1.0.0 → 1.2.1

data/lib/sportdb/catalogs/event_info.rb

@@ -0,0 +1,74 @@
+module CatalogDb
+module Metal
+
+class EventInfo < Record
+    self.tablename = 'event_infos'
+
+    self.columns = ['league_key', 
+                    'season', 
+                    'teams',    
+                    'matches',
+                    'goals',
+                    'start_date',  
+                    'end_date']
+          
+
+     def self._build_event_info( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        ## note: move EventInfo from sports/format to structs - why? why not?
+        @cache[ row[0] ] ||= SportDb::Import::EventInfo.new(
+                                league: _to_league( row[0] ),
+                                season: Season.parse(row[1]),
+                                teams: row[2],
+                                matches: row[3],
+                                goals: row[4],
+                                start_date: row[5] ? Date.strptime( row[5], '%Y-%m-%d' ) : nil,
+                                end_date: row[6]   ? Date.strptime( row[6], '%Y-%m-%d' ) : nil,
+                              )   
+     end                
+          
+
+    def self.seasons( league )
+      league_key = league.is_a?( String ) ? League.find!( league ).key 
+                                          : league.key
+
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM event_infos 
+        WHERE event_infos.league_key = '#{league_key}' 
+SQL
+
+         rows.map {|row| _build_event_info( row ) }
+    end
+
+    
+    def self.find_by( league:, season: )
+      league_key = league.is_a?( String ) ? League.find!( league ).key 
+                                          : league.key
+      season_key = season.is_a?( String ) ? Season.parse(season).key 
+                                          : season.key
+
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM event_infos 
+        WHERE event_infos.league_key = '#{league_key}' AND
+              event_infos.season     = '#{season_key}' 
+SQL
+
+      if rows.empty?
+           nil
+      elsif rows.size > 1  ## not possible in theory
+       puts "** !!! ERROR - expected zero or one rows; got (#{rows.size}):"
+       pp rows
+       exit 1
+      else
+         _build_event_info( rows[0] )
+      end
+    end
+
+end  # class EventInfo
+end  # module Metal
+end  # module CatalogDb
+
+

data/lib/sportdb/catalogs/ground.rb

@@ -0,0 +1,106 @@
+module CatalogDb
+module Metal
+
+class Ground < Record
+    self.tablename = 'grounds'
+
+    self.columns = ['key', 
+                    'name', 
+                    'alt_names',    #2
+                    'city_key',     #3
+                    'country_key',  #4
+                    'district',     #5
+                    'address',      #6
+                  ]
+
+
+    def self._build_ground( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        @cache[ row[0] ] ||= begin 
+                                ground = Sports::Ground.new(
+                                         key:  row[0],
+                                         name: row[1] )
+                                
+                                if row[2]
+                                  alt_names = row[2].split( '|' )
+                                  alt_names = alt_names.map { |name| name.strip }
+                                  ground.alt_names += alt_names 
+                                end
+                                ground.city     =  _to_city( row[3] )
+                                ground.country  =  _to_country( row[4] )
+                                ground.district =  row[5]
+                                ground.address  =  row[6]
+                                ground
+                              end                                                     
+    end                
+ 
+
+    def self._find_by_name( name )
+        rows = execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM grounds 
+        INNER JOIN ground_names ON grounds.key  = ground_names.key
+        WHERE ground_names.name = '#{name}' 
+SQL
+       rows 
+    end
+
+    def self._find_by_name_and_country( name, country )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM grounds 
+      INNER JOIN ground_names ON grounds.key  = ground_names.key
+      WHERE ground_names.name = '#{name}' AND 
+            grounds.country_key = '#{country}'
+SQL
+      rows 
+    end
+
+    def self._find_by_name_and_city( name, city )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM grounds 
+      INNER JOIN ground_names ON grounds.key  = ground_names.key
+      WHERE ground_names.name = '#{name}' AND 
+            grounds.city_key = '#{city}'
+SQL
+      rows 
+    end
+
+
+
+  ## match - always returns an array (with one or more matches)
+  def self.match_by( name:, 
+                     country: nil,
+                     city:    nil )
+    ## note: allow passing in of country key too (auto-counvert)
+    ##       and country struct too
+    ##     - country assumes / allows the country key or fifa code for now
+
+    ##  note: ALWAYS unaccent 1st in normalize  
+    ##            - add upstream - why? why not?
+    # note: returns empty array (e.g. []) if no match and NOT nil
+    nameq = normalize( unaccent(name) )
+
+    rows = if country && city.nil?
+              country = _country( country )
+              countryq = country.key
+              _find_by_name_and_country( nameq, countryq )
+           elsif city && country.nil?
+              city    = _city( city )
+              cityq   = city.key 
+              _find_by_name_and_city( nameq, cityq )
+           elsif city.nil? && country.nil?
+             _find_by_name( nameq )
+           else
+              raise ArgumentError, "unsupported city query params pairs; sorry"
+           end
+    
+    rows.map {|row| _build_ground( row )}
+  end
+end  # class Ground
+
+end  # module Metal
+end  # module CatalogDb
+

data/lib/sportdb/catalogs/league.rb

@@ -0,0 +1,170 @@
+module CatalogDb
+module Metal
+
+class League < Record
+    self.tablename = 'leagues'
+
+    self.columns = ['key',
+                    'name',
+                    'intl',  # international tournament?
+                    'clubs', # clubs or national teams?
+                    'country_key']
+
+
+    def self.cache() @cache ||= Hash.new; end
+
+
+     def self._record( key )  ## use _record! as name - why? why not?
+        if (rec = cache[ key ])
+          rec   ## return cached
+        else  ## query and cache and return
+        rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM leagues
+      WHERE leagues.key = '#{key}'
+SQL
+
+          ## todo/fix: also assert for rows == 1 AND NOT MULTIPLE records - why? why not?
+          if rows.empty?
+            raise ArgumentError, "league record with key #{key} not found"
+          else
+            _build_league( rows[0] )
+          end
+        end
+     end
+
+     def self._build_league( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        cache[ row[0] ] ||= Sports::League.new(
+                                key: row[0],
+                                name: row[1],
+                                intl: _to_bool( row[2] ),
+                                clubs: _to_bool( row[3] ),
+                                country: row[4] ? _to_country( row[4] ) : nil,
+                             )
+     end
+
+      def self.match_by_code( code,
+                               country: nil )
+        ## note: match must for now always include name
+        ###  todo/fix: allow special normalize formula for
+        ##                 code - why? why not?
+        ##              e.g. allow ö1 or ö or such - why? why not?
+        code = normalize( unaccent(code) )
+
+        rows = nil
+        if country.nil?
+            ## note: returns empty array if no match and NOT nil
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM leagues
+        INNER JOIN league_codes ON leagues.key  = league_codes.key
+        WHERE league_codes.code = '#{code}'
+SQL
+        else  ## filter by country
+          ## note: also skip international leagues & cups (e.g. champions league etc.) for now - why? why not?
+
+          ## note: country assumes / allows the country key or fifa code for now
+          ## note: allow passing in of country struct too
+          country_rec = _country( country )
+
+          rows = execute( <<-SQL )
+          SELECT #{self.columns.join(', ')}
+          FROM leagues
+          INNER JOIN league_codes ON leagues.key  = league_codes.key
+          WHERE league_codes.code = '#{code}' AND
+                leagues.country_key = '#{country_rec.key}'
+
+SQL
+        end
+
+         ## wrap results array into struct records
+         rows.map {|row| _build_league( row )}
+      end
+
+      def self.match_by_name( name,
+                               country: nil )
+        ## note: match must for now always include name
+        name = normalize( unaccent(name) )
+
+        rows = nil
+        if country.nil?
+            ## note: returns empty array if no match and NOT nil
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM leagues
+        INNER JOIN league_names ON leagues.key  = league_names.key
+        WHERE league_names.name = '#{name}'
+SQL
+        else  ## filter by country
+          ## note: also skip international leagues & cups (e.g. champions league etc.) for now - why? why not?
+
+          ## note: country assumes / allows the country key or fifa code for now
+          ## note: allow passing in of country struct too
+          country_rec = _country( country )
+
+          rows = execute( <<-SQL )
+          SELECT #{self.columns.join(', ')}
+          FROM leagues
+          INNER JOIN league_names ON leagues.key  = league_names.key
+          WHERE league_names.name = '#{name}' AND
+                leagues.country_key = '#{country_rec.key}'
+
+SQL
+        end
+
+         ## wrap results array into struct records
+         rows.map {|row| _build_league( row )}
+      end
+
+     def self.match_by_name_or_code( q,
+                               country: nil )
+        name = normalize( unaccent(q) )
+        code = normalize( unaccent(q) )
+
+        rows = nil
+        if country.nil?
+            ## note: returns empty array if no match and NOT nil
+             rows =  execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM leagues
+        INNER JOIN league_names ON leagues.key  = league_names.key
+        WHERE league_names.name = '#{name}'
+        UNION
+        SELECT #{self.columns.join(', ')}
+        FROM leagues
+        INNER JOIN league_codes ON leagues.key  = league_codes.key
+        WHERE league_codes.code = '#{code}'
+SQL
+        else  ## filter by country
+          ## note: also skip international leagues & cups (e.g. champions league etc.) for now - why? why not?
+
+          ## note: country assumes / allows the country key or fifa code for now
+          ## note: allow passing in of country struct too
+          country_rec = _country( country )
+
+          rows = execute( <<-SQL )
+          SELECT #{self.columns.join(', ')}
+          FROM leagues
+          INNER JOIN league_names ON leagues.key  = league_names.key
+          WHERE league_names.name = '#{name}' AND
+                leagues.country_key = '#{country_rec.key}'
+          UNION
+          SELECT #{self.columns.join(', ')}
+          FROM leagues
+          INNER JOIN league_codes ON leagues.key  = league_codes.key
+          WHERE league_codes.code = '#{code}' AND
+                leagues.country_key = '#{country_rec.key}'
+SQL
+        end
+
+         ## wrap results array into struct records
+         rows.map {|row| _build_league( row )}
+      end
+
+
+end  # class League
+end  # module Metal
+end  # module CatalogDb
+
+

data/lib/sportdb/catalogs/national_team.rb

@@ -0,0 +1,61 @@
+module CatalogDb
+module Metal
+
+class NationalTeam < Record
+    self.tablename = 'national_teams'
+
+    self.columns = ['key', 
+                    'name', 
+                    'code', 
+                    'country_key']
+
+     def self._build_national_team( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        @cache[ row[0] ] ||= begin
+                               team = Sports::NationalTeam.new(
+                                        key: row[0],
+                                        name: row[1],
+                                        code: row[2]   
+                                      )
+
+                                ## note: country for now NOT supported 
+                                ##       via keyword on init!!!
+                                ##    fix - why? why not?
+                                team.country = row[3] ? _to_country( row[3] ) : nil
+                                team      
+                             end
+     end                
+
+    
+
+  def self.find( q )
+    q = normalize( unaccent(q.to_s) )  ## allow symbols too (e.g. use to.s first)
+   
+    rows = execute( <<-SQL )
+    SELECT #{self.columns.join(', ')}
+    FROM national_teams 
+    INNER JOIN national_team_names ON national_teams.key  = national_team_names.key
+    WHERE national_team_names.name = '#{q}' 
+ SQL
+ 
+      if rows.empty? 
+         nil 
+      else 
+          _build_national_team( rows[0] )
+      end   
+  end
+
+
+  def self.find!( q )
+    team = find( q )
+    if team.nil?
+      puts "** !!! ERROR - no match for national team >#{q}< found"
+      exit 1
+    end
+    team
+  end
+end  # class NationalTeam
+
+end  # module Metal
+end  # module CatalogDb

data/lib/sportdb/catalogs/player.rb

@@ -0,0 +1,125 @@
+module CatalogDb
+module Metal
+
+class Player < PlayerRecord
+
+    ## note - tablename is persons!! (NOT players or even people)
+    self.tablename = 'persons'
+
+    self.columns = ['id',           #0
+                    'name',         #1
+                    'alt_names',    #2
+                    'nat',          #3
+                    'height',       #4
+                    'pos',          #5
+                    'birthdate',    #6
+                    'birthplace',   #7
+                  ]
+
+
+    ### todo/fix:
+    ##   change sqlite config to return records as hash NOT array!!!!
+    ##
+
+    def self._build_player( row )
+        ## note: cache structs by key (do NOT rebuild duplicates; reuse)
+        @cache ||= Hash.new
+        @cache[ row[0] ] ||= begin 
+                                ## use Sports::Player.new  - why? why not?
+                                player = Sports::Player.new(
+                                           name:       row[1],
+                                           nat:        row[3],
+                                           height:     row[4],
+                                           pos:        row[5],  ## make pos into an array??
+                                           birthdate:  row[6],  ## todo/fix - convert to date??
+                                           birthplace: row[7],
+                                            )
+                                
+                                if row[2]
+                                  alt_names = row[2].split( '|' )
+                                  alt_names = alt_names.map { |name| name.strip }
+                                  player.alt_names += alt_names 
+                                end
+                                player
+                              end                                                     
+    end                
+ 
+
+    def self._find_by_name( name )
+        rows = execute( <<-SQL )
+        SELECT #{self.columns.join(', ')}
+        FROM persons 
+        INNER JOIN person_names ON persons.id  = person_names.person_id
+        WHERE person_names.name = '#{name}' 
+SQL
+       rows 
+    end
+
+    def self._find_by_name_and_country( name, country )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM persons 
+      INNER JOIN person_names ON persons.id  = person_names.person_id
+      WHERE person_names.name = '#{name}' AND 
+            persons.nat = '#{country}'
+SQL
+      rows 
+    end
+
+    def self._find_by_name_and_year( name, year )
+      ## check if there's a date function for year 
+      ##  (using integer compare instead of string with qoutes???) 
+      ##  use cast to convert year to integer - why? why not? 
+
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM persons 
+      INNER JOIN person_names ON persons.id  = person_names.person_id
+      WHERE person_names.name = '#{name}' AND 
+            CAST(strftime('%Y',persons.birthdate) AS INTEGER) = #{year}
+SQL
+      rows 
+    end
+
+    def self._find_by_name_and_year_and_country( name, year, country )
+      rows = execute( <<-SQL )
+      SELECT #{self.columns.join(', ')}
+      FROM persons 
+      INNER JOIN person_names ON persons.id  = person_names.person_id
+      WHERE person_names.name = '#{name}' AND 
+            CAST(strftime('%Y',persons.birthdate) AS INTEGER) = #{year} AND
+            persons.nat = '#{country}'
+SQL
+      rows 
+    end
+
+
+  ## match - always returns an array (with one or more matches)
+  def self.match_by( name:, 
+                     country: nil,
+                     year:    nil )
+    nameq = normalize( unaccent(name) )
+
+    rows = if country 
+              country = _country( country )
+              countryq = country.key
+              if year
+                _find_by_name_and_year_and_country( nameq, year, countryq ) 
+              else    ## no year (country only)
+                _find_by_name_and_country( nameq, countryq )
+              end
+           elsif year && country.nil?
+              _find_by_name_and_year( nameq, year )
+           elsif year.nil? && country.nil?
+             _find_by_name( nameq )
+           else
+              raise ArgumentError, "unsupported query for player; sorry"
+           end
+    
+    rows.map {|row| _build_player( row )}
+  end
+end  # class Player
+
+end  # module Metal
+end  # module CatalogDb
+

data/lib/sportdb/catalogs/version.rb

@@ -1,13 +1,11 @@
-# encoding: utf-8
-
 
 module SportDb
 module Module
 module Catalogs
 
   MAJOR = 1    ## todo: namespace inside version or something - why? why not??
-  MINOR = 0
-  PATCH = 0
+  MINOR = 2
+  PATCH = 1
   VERSION = [MAJOR,MINOR,PATCH].join('.')
 
   def self.version
@@ -15,7 +13,7 @@ module Catalogs
   end
 
   def self.banner
-    "sportdb-catalogs/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+    "sportdb-catalogs/#{VERSION} on Ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}] in (#{root})"
   end
 
   def self.root