class PackageDefinition(Base, HasDummy):
__tablename__ = 'package_definitions'
id = Column(u'pkg_def_id', INTEGER(), primary_key=True)
deploy_type = Column(String(length=30), nullable=False)
validation_type = Column(String(length=15), nullable=False)
pkg_name = Column(String(length=255), nullable=False)
name = synonym('pkg_name')
path = Column(String(length=255), nullable=False)
repository = Column(String(length=255), nullable=True)
arch = Column(Enum('i386', 'x86_64', 'noarch'),
nullable=False,
server_default='noarch')
build_type = Column(Enum(u'developer', u'hudson', u'jenkins'),
nullable=False,
server_default='jenkins')
build_host = Column(String(length=255), nullable=False)
env_specific = Column(BOOLEAN(), nullable=False, server_default='0')
environment_specific = synonym('env_specific')
created = Column(TIMESTAMP(),
nullable=False,
server_default=func.current_timestamp())
packages = relationship(
'Package',
primaryjoin=("(Package.pkg_def_id == PackageDefinition.id)"
" & (Package.status != 'removed')"),
passive_deletes=True,
)
all_packages = relationship(
'Package',
back_populates='package_definition',
passive_deletes=True,
)
package_names = relationship(
'PackageName',
back_populates="package_definition",
passive_deletes=True,
)
applications = relationship(
'AppDefinition',
secondary=lambda: Base.metadata.tables['project_package'],
passive_deletes=True,
back_populates='package_definitions',
viewonly=True,
)
projects = relationship(
'Project',
secondary=lambda: Base.metadata.tables['project_package'],
passive_deletes=True,
back_populates='package_definitions',
viewonly=True,
)
class Run(BASE):
__tablename__ = 'Run'
run_id = Column(INTEGER(12),
primary_key=True,
auto_increment=True,
default=0)
game_id = Column(VARCHAR(12), primary_key=True)
year = Column(INTEGER(5))
date = Column(DATE)
scoring_team = Column(VARCHAR(3))
conceding_team = Column(VARCHAR(3))
scoring_player = Column(VARCHAR(8))
batter = Column(VARCHAR(8))
responsible_pitcher = Column(VARCHAR(8))
is_earned = Column(BOOLEAN(3))
is_team_earned = Column(BOOLEAN(3))
is_rbi = Column(BOOLEAN(3))
is_sp = Column(BOOLEAN(3))
inning = Column(SMALLINT(3))
outs = Column(TINYINT(1))
class Member(BaseChanges, db.Base):
__tablename__ = 'members'
id = Column(INTEGER(11), primary_key=True)
first_name = Column(VARCHAR(255))
last_name = Column(VARCHAR(255))
address_id = Column(INTEGER(11), ForeignKey('addresses.id'))
address = relationship('Address')
email = Column(VARCHAR(255), unique=True)
password = Column(VARCHAR(255))
pw_salt = Column(VARCHAR(255))
officer = Column(BOOLEAN())
type = Column(VARCHAR(20))
active = Column(BOOLEAN())
institution_id = Column(INTEGER(11), ForeignKey('institutions.id'))
institution = relationship('Institution', back_populates='faculty_members')
host = relationship('Conference', uselist=False, back_populates='host')
presentations = relationship('Presentation',
secondary=member_presentations,
back_populates='presenters')
conferences = relationship('MemberConferences', back_populates='member')
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
def __init__(self, member_data):
print member_data
self.first_name = member_data['first_name']
self.last_name = member_data['last_name']
# self.address_id = member_data['address_id']
self.email = member_data['email']
self.pw_salt = member_data['salt']
self.password = member_data['hash']
self.officer = True if 'officer' in member_data else False
self.active = False
self.type = member_data['type']
# self.institution_id = member_data['institution_id']
def __repr__(self):
return '<Member(id=%r,email=%r>' % (self.id, self.email)
class MemberConferences(BaseChanges, db.Base):
__tablename__ = 'member_conferences'
id = Column(INTEGER(11), primary_key=True, autoincrement=True)
member_id = Column(INTEGER(11), ForeignKey('members.id'), primary_key=True)
conference_id = Column(INTEGER(11),
ForeignKey('conferences.id'),
primary_key=True)
food_pref = Column(VARCHAR(255))
gluten_free = Column(BOOLEAN())
days = Column(VARCHAR(255))
member_paid = Column(BOOLEAN())
member = relationship('Member', back_populates='conferences')
conference = relationship('Conference', back_populates='members')
def __init__(self, data):
self.food_pref = data['food_pref']
self.gluten_free = data['gluten_free']
self.member_paid = False
def __repr__(self):
return "<MemberConference(id=%s, member=%s, conference=%s)>" % (
self.id, self.member_id, self.conference_id)
class MemberConferences(BaseChanges, db.Base):
__tablename__ = 'member_conferences'
member_id = Column('member_id',
INTEGER(11),
ForeignKey('members.id'),
primary_key=True)
conference_id = Column('conference_id',
INTEGER(11),
ForeignKey('conferences.id'),
primary_key=True)
food_pref = Column(VARCHAR(255))
gluten_free = Column(BOOLEAN())
member = relationship('Member', back_populates='conferences')
conference = relationship('Conference', back_populates='members')
class Answer(Base):
__tablename__ = 'zhihu_answers'
q_id = Column(INTEGER(), ForeignKey('zhihu_questions.id'))
question = relationship('Question', backref='answer')
answer_id = Column(INTEGER(), primary_key=True)
author_id = Column(VARCHAR(100))
author_name = Column(NVARCHAR(20))
author_is_advertiser = Column(BOOLEAN())
created_time = Column(DATETIME())
updated_time = Column(DATETIME())
voteup_num = Column(INTEGER())
comment_num = Column(INTEGER())
content = Column(MEDIUMTEXT())
class HwChassis(Base):
__tablename__ = 'hw_chassis'
chassis_id = Column(u'chassis_id', INTEGER(), primary_key=True)
vendor = Column(String(length=20))
height = Column(u'height', INTEGER())
width = Column(u'width', FLOAT())
depth = Column(u'depth', FLOAT())
model = Column(String(length=20))
control = Column(Enum(u'digi', u'ipmi', u'libvirt', u'rlm', u'vmware'))
virtual = Column(BOOLEAN(), nullable=False, server_default='0')
__table_args__ = (
UniqueConstraint(u'vendor', u'model'),
{
'mysql_engine': 'InnoDB',
'mysql_charset': 'utf8',
},
)
class PackageLocation(Base):
__tablename__ = 'package_locations'
id = Column(u'pkgLocationID', INTEGER(), primary_key=True)
project_type = Column(Enum(u'application', u'kafka-config', u'tagconfig'),
nullable=False,
server_default='application')
pkg_type = Column(String(length=255), nullable=False)
pkg_name = Column(String(length=255), nullable=False, unique=True)
name = synonym('pkg_name')
app_name = Column(String(length=255), nullable=False, unique=True)
path = Column(String(length=255), nullable=False, unique=True)
arch = Column(Enum(u'i386', u'x86_64', u'noarch'),
nullable=False,
server_default='noarch')
build_host = Column(String(length=30), nullable=False)
environment = Column(BOOLEAN(), nullable=False)
app_definitions = relationship('AppDefinition',
secondary='app_packages',
backref='package_locations')
class PlateAppearance(BASE):
__tablename__ = 'PlateAppearance'
game_id = Column(VARCHAR(12), primary_key=True, auto_increment=False)
year = Column(INTEGER(5), primary_key=True, auto_increment=False)
date = Column(DATE)
pa_id = Column(INTEGER(6),
primary_key=True,
auto_increment=True,
default=0)
batter_id = Column(VARCHAR(8))
batter_team = Column(VARCHAR(8))
batter_hand = Column(VARCHAR(3))
pitcher_id = Column(VARCHAR(8))
pitcher_team = Column(VARCHAR(8))
pitcher_hand = Column(VARCHAR(3))
play = Column(VARCHAR(150))
inning = Column(SMALLINT(3))
batting_team_home = Column(BOOLEAN(3))
outs = Column(TINYINT(1))
balls = Column(TINYINT(1))
strikes = Column(TINYINT(1))
sequence = Column(VARCHAR(50))
away_runs = Column(SMALLINT(3))
home_runs = Column(SMALLINT(3))
first_runner_id = Column(VARCHAR(8))
first_dest = Column(VARCHAR(3))
second_runner_id = Column(VARCHAR(8))
second_dest = Column(VARCHAR(3))
third_runner_id = Column(VARCHAR(8))
third_dest = Column(VARCHAR(3))
field_pos = Column(SMALLINT(3))
lineup_pos = Column(SMALLINT(3))
event_type = Column(SMALLINT(3))
ab_flag = Column(BOOLEAN(3))
pa_flag = Column(BOOLEAN(3))
sp_flag = Column(BOOLEAN(3))
hit_val = Column(SMALLINT(3))
sac_bunt = Column(BOOLEAN(3))
sac_fly = Column(BOOLEAN(3))
outs_on_play = Column(SMALLINT(3))
rbi = Column(SMALLINT(3))
runs_on_play = Column(SMALLINT(3))
first_scorer = Column(VARCHAR(8))
second_scorer = Column(VARCHAR(8))
third_scorer = Column(VARCHAR(8))
fourth_scorer = Column(VARCHAR(8))
first_runner_event = Column(VARCHAR(3))
second_runner_event = Column(VARCHAR(3))
third_runner_event = Column(VARCHAR(3))
wp = Column(BOOLEAN(3))
pb = Column(BOOLEAN(3))
fielder_id = Column(VARCHAR(8))
ball_type = Column(VARCHAR(1))
bunt_flag = Column(BOOLEAN(3))
foul_flag = Column(BOOLEAN(3))
hit_loc = Column(SMALLINT(3))
first_error = Column(VARCHAR(8))
second_error = Column(VARCHAR(8))
third_error = Column(VARCHAR(8))
num_errors = Column(SMALLINT(3))
batter_dest = Column(VARCHAR(3))
first_po = Column(VARCHAR(8))
second_po = Column(VARCHAR(8))
third_po = Column(VARCHAR(8))
first_ast = Column(VARCHAR(8))
second_ast = Column(VARCHAR(8))
third_ast = Column(VARCHAR(8))
fourth_ast = Column(VARCHAR(8))
fifth_ast = Column(VARCHAR(8))
catcher = Column(VARCHAR(8))
first_base = Column(VARCHAR(8))
second_base = Column(VARCHAR(8))
third_base = Column(VARCHAR(8))
shortstop = Column(VARCHAR(8))
left_field = Column(VARCHAR(8))
center_field = Column(VARCHAR(8))
right_field = Column(VARCHAR(8))
class Presentation(BaseChanges, db.Base):
__tablename__ = 'presentations'
id = Column(INTEGER(11), primary_key=True)
title = Column(VARCHAR(255), unique=True)
summary = Column(TEXT())
files_url = Column(
TEXT()) ##trying to utilize Google Drive for file upload
approved = Column(BOOLEAN())
duration = Column(INTEGER(2)) #time in minutes
datetime = Column(DATETIME())
presenters = relationship('Member',
secondary=member_presentations,
back_populates='presentations')
conference_id = Column(INTEGER(11), ForeignKey('conferences.id'))
conference = relationship('Conference',
back_populates='presentations',
uselist=False)
created_at = Column(DATETIME(), default=func.utc_timestamp())
updated_at = Column(DATETIME(),
default=func.utc_timestamp(),
onupdate=func.utc_timestamp())
def __init__(self, present_info):
self.title = present_info['title']
self.summary = present_info['summary']
self.approved = False
self.conference_id = present_info['conference_id']
self.duration = present_info['duration'] #time in minutes
self.add_files(
present_info['files']) if 'files' in present_info else None
self.presenters.append(**present_info['presenters'])
##Presenters should be added in the controller
#Check for year folder
# Create it if it doesn't exist
#Create a folder for the presentation (using presentation title)
#save folder id and place files in the folder if there are any
def add_files(self, files):
conference = Conference.query.get(self.conference_id)
#check for conference year folder, create if none
year_folder = drive.files().list(
q="name=" + conference['year'] +
" and mimeType='application/vnd.google-apps.folder'")
if len(year_folder['files']) == 0:
folder_params = {
'mimeType': "application/vnd.google-apps.folder",
'name': conference['year'],
'parents': sens.drive_root_folder_id
}
drive.files().create(body=folder_params).execute()
#check for presentation folder, create if none
present_folder = drive.files().list(
q="name=" + self.title +
" and mimeType='application/vnd.google-apps.folder'")
if len(present_folder['files']) == 0:
folder_params = {
'mimeType': "application/vnd.google-apps.folder",
'name': self.title,
'parents': year_folder['files'][0]['id']
}
drive.files().create(body=folder_params).execute()
#Upload each file to the folder
for file in files:
file_data = {
'name': file['name'],
'parents': present_folder['files'][0]['id']
}
drive.files.create(body=file_data, media_body=file['file'])
self.files_url = drive.files(
fileId=present_folder['files'][0]['id'])['webViewLink']
class Model(BASE, ModelUtils):
__tablename__ = 'model'
# composite primary key, cid + uid + version + meta_version
# composite foreign key, cid + uid
cid = Column(VARCHAR(128), primary_key=True)
uid = Column(VARCHAR(128), primary_key=True)
meta_version = Column(INTEGER(unsigned=True, primary_key=True))
__table_args__ = (ForeignKeyConstraint([cid, uid], [User.cid, User.uid]), {
'mysql_engine': MYSQL_ENGINE,
'mysql_charset': MYSQL_CHARSET,
'mysql_collate': MYSQL_COLLATE
})
# models
user = relationship('User', back_populates='models')
maturity = Column(FLOAT(unsigned=True))
accuracy = Column(FLOAT(unsigned=True))
is_ready = Column(BOOLEAN())
create_time = Column(DATETIME(), server_default=func.now(), nullable=False)
last_update_time = Column(DATETIME(),
server_default=func.now(),
onupdate=func.now(),
nullable=False)
_languages = Column(VARCHAR(2048))
@staticmethod
def generate_id(meta_version, user_id):
# meta_version should refer Version
return HashUtility.get_normalized_str_sha256(
f'{meta_version}{user_id}')
@staticmethod
def verify_meta_version(meta_version):
if meta_version not in VALID_META_VERSIONS:
raise InvalidVersion(meta_version)
@validates('meta_version')
def validate_meta_version(self, _, meta_version):
Meta.verify_version(meta_version)
return meta_version
@hybrid_property
def languages(self):
# load json string to dict if it is not None
if not self._languages:
return self._languages
return json.loads(self._languages)
@languages.setter
def languages(self, languages):
# dump to json string if it is not None
if languages:
self._languages = json.dumps(languages)
else:
self._languages = None
def __init__(self,
cid,
uid,
meta_version,
*,
maturity=0.0,
accuracy=0.0,
is_ready=False,
languages=None):
self.cid = cid
self.uid = uid
self.meta_version = meta_version
self.maturity = maturity
self.accuracy = accuracy
self.is_ready = is_ready
self.languages = languages
def __repr__(self):
return f'[\n' \
f'<cid:{self.cid}>\n'\
f'<uid:{self.uid}>\n'\
f'<meta_version:{self.meta_version}>\n'\
f'<maturity:{self.maturity}>\n'\
f'<accuracy:{self.accuracy}>\n' \
f'<create_time:{self.create_time}>\n' \
f'<last_update_time:{self.last_update_time}>\n' \
f'<languages:{self.languages}>\n' \
f']'
def to_dict(self):
res_dict = self.__dict__.copy()
# remove this key for JSON serializable
if '_sa_instance_state' in res_dict:
res_dict.pop('_sa_instance_state', None)
if '_languages' in res_dict:
if res_dict['_languages'] is not None:
# Don't be confused with this warning
# Sqlalchemy use @hybrid_property instead of @property for more general
# use case (eg, filter)
res_dict['languages'] = self.languages
else:
res_dict['languages'] = None
res_dict.pop('_languages', None)
return res_dict
class AppDeployment(Base):
__tablename__ = 'app_deployments'
id = Column(u'AppDeploymentID', INTEGER(), primary_key=True)
deployment_id = Column(u'DeploymentID',
INTEGER(),
ForeignKey('deployments.DeploymentID',
ondelete='cascade'),
nullable=False)
deployment = relationship("Deployment", uselist=False)
app_id = Column(u'AppID',
SMALLINT(display_width=6),
ForeignKey('app_definitions.AppID', ondelete='cascade'),
nullable=False)
application = relationship("AppDefinition", uselist=False)
target = synonym('application')
package_id = Column(INTEGER(),
ForeignKey('packages.package_id', ondelete='cascade'),
nullable=False)
package = relationship(
"Package",
uselist=False,
back_populates="app_deployments",
)
user = Column(String(length=32), nullable=False)
status = Column(Enum(
'complete',
'incomplete',
'inprogress',
'invalidated',
'pending',
'validated',
),
nullable=False)
environment_id = Column(u'environment_id',
INTEGER(),
ForeignKey('environments.environmentID',
ondelete='cascade'),
nullable=False)
realized = Column(TIMESTAMP(),
nullable=False,
server_default=func.current_timestamp())
created_at = synonym('realized')
duration = Column(FLOAT(), nullable=False, server_default="0")
skewed = Column(BOOLEAN(), nullable=False, server_default='0')
environment_obj = relationship('Environment')
__table_args__ = (UniqueConstraint(u'package_id', u'AppID',
u'environment_id', u'realized'), )
@hybrid_property
def env(self):
return self.environment_obj.env
@env.expression
def env(cls):
return select([Environment.env]).\
where(Environment.id == cls.environment_id).correlate(cls).\
label('env')
@hybrid_property
def environment(self):
return self.environment_obj.environment
@environment.expression
def environment(cls):
return select([Environment.environment]).\
where(Environment.id == cls.environment_id).correlate(cls).\
label('environment')
@hybrid_property
def needs_validation(self):
"""
Complete and incomplete deployments require validation
"""
return self.status in ('complete', 'incomplete')
@needs_validation.expression
def needs_validation(cls):
return cls.status.in_(['complete', 'incomplete'])
class Paper(Base):
__tablename__ = 'paper'
id = Column(INTEGER(unsigned=True),
primary_key=True,
autoincrement=True,
nullable=False)
id_scp = Column(BIGINT(unsigned=True), nullable=False, unique=True)
eid = Column(VARCHAR(45), nullable=False, unique=True)
title = Column(VARCHAR(512), nullable=False)
type = Column(VARCHAR(2), nullable=False)
type_description = Column(VARCHAR(45), nullable=True)
abstract = Column(TEXT(), nullable=True)
total_author = Column(SMALLINT(unsigned=True), nullable=False)
open_access = Column(BOOLEAN(create_constraint=True,
name='open_access_check'),
nullable=False)
cited_cnt = Column(SMALLINT(unsigned=True), nullable=True)
url = Column(VARCHAR(256), nullable=False, unique=True)
article_no = Column(VARCHAR(45), nullable=True)
date = Column(DATE(), nullable=False)
fund_id = Column(BIGINT(unsigned=True),
ForeignKey('fund.id'),
nullable=True)
source_id = Column(INTEGER(unsigned=True),
ForeignKey('source.id'),
nullable=True)
doi = Column(VARCHAR(256), nullable=True, unique=True)
volume = Column(VARCHAR(45), nullable=True)
issue = Column(VARCHAR(45), nullable=True)
page_range = Column(VARCHAR(45), nullable=True)
retrieval_time = Column(DATETIME(), nullable=False)
create_time = Column(DATETIME(),
nullable=False,
server_default=text('CURRENT_TIMESTAMP'))
update_time = Column(
DATETIME(),
nullable=False,
server_default=text('CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP'))
# Relationships
fund = relationship('Fund', back_populates='papers')
source = relationship('Source', back_populates='papers')
keywords = relationship('Keyword',
secondary=Paper_Keyword,
back_populates='papers')
authors = relationship('Paper_Author', back_populates='paper')
def __init__(
self,
id_scp,
eid,
title,
type,
total_author,
open_access,
cited_cnt,
url,
date,
retrieval_time,
type_description=None,
abstract=None,
article_no=None,
fund_id=None,
source_id=None,
doi=None,
volume=None,
issue=None,
page_range=None,
create_time=None,
update_time=None,
):
self.id_scp = id_scp
self.eid = eid
self.title = title
self.type = type
self.type_description = type_description
self.abstract = abstract
self.total_author = total_author
self.open_access = open_access
self.cited_cnt = cited_cnt
self.url = url
self.article_no = article_no
self.fund_id = fund_id
self.source_id = source_id
self.doi = doi
self.volume = volume
self.issue = issue
self.date = date
self.page_range = page_range
self.retrieval_time = retrieval_time
self.create_time = create_time
self.update_time = update_time
def __repr__(self):
max_len = 50
if len(self.title) <= max_len:
return f'{self.id_scp}: {self.title}; DOI: {self.doi}'
return f'{self.id_scp}: {self.title[:max_len-3]}...; DOI: {self.doi}'
def get_year(self):
return self.date.year
class Game(BASE):
__tablename__ = 'Game'
game_id = Column(VARCHAR(12), primary_key=True, auto_increment=False)
year = Column(INTEGER(5))
date = Column(DATE)
home_team = Column(VARCHAR(3))
home_team_runs = Column(SMALLINT(3))
away_team = Column(VARCHAR(3))
away_team_runs = Column(SMALLINT(3))
winning_team = Column(VARCHAR(3))
losing_team = Column(VARCHAR(3))
innings = Column(SMALLINT(3))
site = Column(VARCHAR(5))
start_time = Column(VARCHAR(10))
is_day = Column(BOOLEAN(3))
temp = Column(SMALLINT(3))
wind_dir = Column(VARCHAR(10))
wind_speed = Column(SMALLINT(3))
field_cond = Column(VARCHAR(20))
precip = Column(VARCHAR(15))
sky = Column(VARCHAR(15))
time_of_game = Column(INTEGER(5))
attendance = Column(INTEGER(6))
winning_pitcher = Column(VARCHAR(8))
losing_pitcher = Column(VARCHAR(8))
save = Column(VARCHAR(8))
starting_pitcher_home = Column(VARCHAR(8))
starting_catcher_home = Column(VARCHAR(8))
starting_first_home = Column(VARCHAR(8))
starting_second_home = Column(VARCHAR(8))
starting_third_home = Column(VARCHAR(8))
starting_short_home = Column(VARCHAR(8))
starting_left_home = Column(VARCHAR(8))
starting_center_home = Column(VARCHAR(8))
starting_right_home = Column(VARCHAR(8))
starting_pitcher_away = Column(VARCHAR(8))
starting_catcher_away = Column(VARCHAR(8))
starting_first_away = Column(VARCHAR(8))
starting_second_away = Column(VARCHAR(8))
starting_third_away = Column(VARCHAR(8))
starting_short_away = Column(VARCHAR(8))
starting_left_away = Column(VARCHAR(8))
starting_center_away = Column(VARCHAR(8))
starting_right_away = Column(VARCHAR(8))
starting_dh_home = Column(VARCHAR(8))
starting_dh_away = Column(VARCHAR(8))
home_team_er = Column(SMALLINT(3))
away_team_er = Column(SMALLINT(3))
starting_pitcher_home_er = Column(SMALLINT(3))
starting_pitcher_home_r = Column(SMALLINT(3))
starting_pitcher_away_er = Column(SMALLINT(3))
starting_pitcher_away_r = Column(SMALLINT(3))
relief_pitcher1 = Column(VARCHAR(8))
relief_pitcher1_er = Column(SMALLINT(3))
relief_pitcher1_r = Column(SMALLINT(3))
relief_pitcher2 = Column(VARCHAR(8))
relief_pitcher2_er = Column(SMALLINT(3))
relief_pitcher2_r = Column(SMALLINT(3))
relief_pitcher3 = Column(VARCHAR(8))
relief_pitcher3_er = Column(SMALLINT(3))
relief_pitcher3_r = Column(SMALLINT(3))
relief_pitcher4 = Column(VARCHAR(8))
relief_pitcher4_er = Column(SMALLINT(3))
relief_pitcher4_r = Column(SMALLINT(3))
relief_pitcher5 = Column(VARCHAR(8))
relief_pitcher5_er = Column(SMALLINT(3))
relief_pitcher5_r = Column(SMALLINT(3))
relief_pitcher6 = Column(VARCHAR(8))
relief_pitcher6_er = Column(SMALLINT(3))
relief_pitcher6_r = Column(SMALLINT(3))
relief_pitcher7 = Column(VARCHAR(8))
relief_pitcher7_er = Column(SMALLINT(3))
relief_pitcher7_r = Column(SMALLINT(3))
relief_pitcher8 = Column(VARCHAR(8))
relief_pitcher8_er = Column(SMALLINT(3))
relief_pitcher8_r = Column(SMALLINT(3))
relief_pitcher9 = Column(VARCHAR(8))
relief_pitcher9_er = Column(SMALLINT(3))
relief_pitcher9_r = Column(SMALLINT(3))
relief_pitcher10 = Column(VARCHAR(8))
relief_pitcher10_er = Column(SMALLINT(3))
relief_pitcher10_r = Column(SMALLINT(3))
relief_pitcher11 = Column(VARCHAR(8))
relief_pitcher11_er = Column(SMALLINT(3))
relief_pitcher11_r = Column(SMALLINT(3))
relief_pitcher12 = Column(VARCHAR(8))
relief_pitcher12_er = Column(SMALLINT(3))
relief_pitcher12_r = Column(SMALLINT(3))
relief_pitcher13 = Column(VARCHAR(8))
relief_pitcher13_er = Column(SMALLINT(3))
relief_pitcher13_r = Column(SMALLINT(3))
relief_pitcher14 = Column(VARCHAR(8))
relief_pitcher14_er = Column(SMALLINT(3))
relief_pitcher14_r = Column(SMALLINT(3))
relief_pitcher15 = Column(VARCHAR(8))
relief_pitcher15_er = Column(SMALLINT(3))
relief_pitcher15_r = Column(SMALLINT(3))
relief_pitcher16 = Column(VARCHAR(8))
relief_pitcher16_er = Column(SMALLINT(3))
relief_pitcher16_r = Column(SMALLINT(3))
relief_pitcher17 = Column(VARCHAR(8))
relief_pitcher17_er = Column(SMALLINT(3))
relief_pitcher17_r = Column(SMALLINT(3))
relief_pitcher18 = Column(VARCHAR(8))
relief_pitcher18_er = Column(SMALLINT(3))
relief_pitcher18_r = Column(SMALLINT(3))
relief_pitcher19 = Column(VARCHAR(8))
relief_pitcher19_er = Column(SMALLINT(3))
relief_pitcher19_r = Column(SMALLINT(3))