class DBVideoQueue(BaseModel):
__tablename__ = 'videos_queue'
video_name = Column(VARCHAR(4096))
hash_video = Column(VARCHAR(100))
is_in_progress = Column(BOOLEAN(), nullable=False, default=False)
is_done = Column(BOOLEAN(), nullable=False, default=False)
is_delete = Column(BOOLEAN(), nullable=False, default=False)
class DBMessage(BaseModel):
__tablename__ = 'messages'
sender_id = Column(Integer, nullable=False)
recipient_id = Column(Integer, nullable=False)
message = Column(TEXT)
is_delete_sender = Column(BOOLEAN(), nullable=False, default=False)
is_delete_recipient = Column(BOOLEAN(), nullable=False, default=False)
class WithdrawConfig(ORMBase):
"""
提币配置表
"""
__tablename__ = 'tb_withdraw_config'
#关于外键:
# https://blog.csdn.net/lucyxu107/article/details/81743529
# https://www.cnblogs.com/chen1930/p/6224676.html
# pro_id = Column(key='pro_id', type_=Integer(), nullable=False, comment='项目方id')
id = Column( key='id', type_=Integer(), primary_key=True, autoincrement=True , comment='id 自增')
token_name = Column(key='token_name', type_=String(20), nullable=False, comment='币种名')
address = Column(key='address', type_=String(100), nullable=False, comment='出币地址' )
min_amount = Column( key='min_amount', type_= DECIMAL(precision=28, scale=8, decimal_return_scale=8, asdecimal=True), nullable=False, comment='最大提币金额' )
max_amount = Column( key='max_amount', type_= DECIMAL(precision=28, scale=8, decimal_return_scale=8, asdecimal=True), nullable=False, comment='最小提币金额' )
balance_threshold_to_sms = Column( key='balance_threshold_to_sms', type_= DECIMAL(precision=28, scale=8, decimal_return_scale=8, asdecimal=True), nullable=False, comment='短信通知阈值' )
is_open = Column( key='is_open', type_=BOOLEAN(), nullable=True, comment='提币通过是否开启' )
# pro_id = Column(Integer(), ForeignKey('tb_project.pro_id'))
pro_id = Column(Integer(), ForeignKey(Project.pro_id, ondelete='CASCADE'), comment='项目方ID')
project = relationship("Project", backref='withdraw_config_ref_project')
__table_args__ = (
UniqueConstraint('token_name', 'pro_id', name='uidx_token_name_pro_id'), #联合唯一索引
)
def _createMonitorErrorFlagsSchema(schemaName, metadata):
schema = Table(
schemaName,
metadata,
# Issue UID
Column("uid",
mysql.VARCHAR(length=_MAX_MONITOR_ISSUES_ID_LEN),
primary_key=True,
nullable=False),
PrimaryKeyConstraint("uid", name=schemaName + "_pk"),
# Issue name
Column("name",
mysql.VARCHAR(length=_MAX_MONITOR_ISSUES_ID_LEN),
nullable=False),
# Should report issue flag
Column("should_report", BOOLEAN(), nullable=False),
# Datetime of last issue occurrence
Column("last_occurrence",
DATETIME(),
nullable=False,
server_default=func.current_timestamp()),
# Count of issue occurrences
Column("occurrence_count", INTEGER, nullable=True, autoincrement=True),
mysql_CHARSET=MYSQL_CHARSET,
mysql_COLLATE=MYSQL_COLLATE,
)
return schema
class BaseModel(Base):
__abstract__ = True
id = Column(
Integer,
nullable=False,
unique=True,
primary_key=True,
autoincrement=True
)
created_at = Column(
TIMESTAMP,
nullable=False,
default=datetime.datetime.utcnow
)
update_at = Column(
TIMESTAMP,
nullable=False,
default=datetime.datetime.utcnow,
onupdate=datetime.datetime.utcnow
)
is_delete = Column(
BOOLEAN(),
nullable=False,
default=False)
def __repr__(self):
return f'{self.__class__.__name__}'
class DBMessage(BaseModel):
__tablename__ = 'message'
sender_id = Column(Integer, ForeignKey('user.id'), nullable=False)
recipient_id = Column(Integer, ForeignKey('user.id'), nullable=False)
message = Column(NVARCHAR(), nullable=False)
is_delete = Column(BOOLEAN(), nullable=False, default=False)
class Assignment(Base):
'An nbgrader assignment'
__tablename__ = 'assignments'
# in case assignment name needs to be changed
_id = Column(INTEGER, primary_key=True)
id = Column(TEXT)
course_id = Column(INTEGER, ForeignKey("courses._id"))
submissions = relationship("Submission", backref="assignment")
files = relationship("File", secondary=assignment_files_assoc_table)
released = BOOLEAN()
due = Column(TIMESTAMP)
# TODO: timezoon
def __init__(self, name, course):
'Initialize with assignment name and course'
self.id = name
self.course = course
def __str__(self):
return '<Assignment %s>' % self.id
def delete(self, db):
'Remove assignment and dependent data (files, submissions)'
for file_obj in self.files:
file_obj.delete(db)
for submission in self.submissions:
submission.delete(db)
db.delete(self)
class DBMessage(BaseModel):
__tablename__ = 'message'
user_message = Column(VARCHAR(200), nullable=False)
recipient = Column(VARCHAR(50), nullable=False)
sender_id = Column(INT, nullable=False)
recipient_id = Column(INT, nullable=False)
is_deleted = Column(BOOLEAN(), nullable=False, default=False)
class DBMessage(BaseModel):
__tablename__ = 'messages'
sender_id = Column(INTEGER(), nullable=False)
recipient_id = Column(INTEGER(), nullable=False)
message = Column(VARCHAR())
is_delete = Column(BOOLEAN(), nullable=False, default=False)
class DBUser(BaseModel):
__tablename__ = 'users'
login = Column(VARCHAR(20), unique=True, nullable=False)
password = Column(LargeBinary(), nullable=False)
first_name = Column(VARCHAR(50))
last_name = Column(VARCHAR(50))
is_delete = Column(BOOLEAN(), nullable=False, default=False)
def test_boolean(self):
for type_, expected in [
(BOOLEAN(), "BOOL"),
(Boolean(), "BOOL"),
(mysql.TINYINT(1), "TINYINT(1)"),
(mysql.TINYINT(1, unsigned=True), "TINYINT(1) UNSIGNED"),
]:
self.assert_compile(type_, expected)
class DBUser(BaseModel):
__tablename__ = 'users'
login = Column(VARCHAR(255), nullable=False, unique=True)
password = Column(VARBINARY(), nullable=False)
first_name = Column(VARCHAR(255))
last_name = Column(VARCHAR(255))
is_delete = Column(BOOLEAN(), nullable=False, default=False)
class DBEmployee(BaseModel):
__tablename__ = 'employees'
login = Column(VARCHAR(20), unique=True, nullable=False)
password = Column(VARBINARY(), nullable=False)
first_name = Column(VARCHAR(50))
last_name = Column(VARCHAR(50))
is_delete = Column(BOOLEAN(), nullable=False, default=False)
position = Column(VARCHAR(50))
department = Column(VARCHAR(50))
class User(Base):
__tablename__= "Users"
uuid = Column(CHAR(36), primary_key=True)
firstname = Column(VARCHAR(45))
lastname = Column(VARCHAR(45))
fb_access_token = Column(VARCHAR(255))
fb_email = Column(VARCHAR(45))
fb_id = Column(BIGINT)
active = Column(BOOLEAN())
recipients = relationship("Recipient", secondary=association_table, back_populates="users")
class Utility(Base):
""" Utility model to store utility(shop) details.
"""
__tablename__ = 'utility'
id = Column('id', Integer, primary_key=True, autoincrement=True)
name = Column('name', String(255), nullable=False)
description = Column('description', String(512), nullable=False)
image = Column('image', String(512))
user_utility_id = Column(Integer, ForeignKey('user.id'), nullable=False)
utility_item = relationship('UtilityItem')
address = Column('address', String(512), nullable=False)
approval_count = Column('approval_count', Integer, default=0)
registered = Column('registered', BOOLEAN(), default=False)
# define methods for Utility model
def __init__(self, **kwargs):
super(Utility, self).__init__(**kwargs)
def create(self):
""" Adds new utility to db.
"""
session.add(self)
session.commit()
def get(self, id):
""" Returns the Utility data for the specified id.
:param id: id for the requested Utility.
:param type: int
"""
return session.query(Utility).filter(Utility.id == id).first()
def all(self):
""" Returns all utilities in db.
"""
return session.query(Utility).all()
def save(self):
""" Updates the Utility in db.
"""
session.commit()
def get_user_utility(self, id):
""" Gets user id owned utilities.
"""
return session.query(Utility).filter(
Utility.user_utility_id == id).all()
def get_owner(self, id):
""" Returns the id for the utility owner.
"""
owner = session.query(Utility).filter(Utility.id == id).first()
return owner.id
def test_type_reflection(self):
metadata = self.metadata
# (ask_for, roundtripped_as_if_different)
specs = [
(String(), String()),
(String(1), String(1)),
(String(3), String(3)),
(Text(), Text()),
(Unicode(), String()),
(Unicode(1), String(1)),
(Unicode(3), String(3)),
(UnicodeText(), Text()),
(CHAR(1), ),
(CHAR(3), CHAR(3)),
(NUMERIC, NUMERIC()),
(NUMERIC(10, 2), NUMERIC(10, 2)),
(Numeric, NUMERIC()),
(Numeric(10, 2), NUMERIC(10, 2)),
(DECIMAL, DECIMAL()),
(DECIMAL(10, 2), DECIMAL(10, 2)),
(INTEGER, INTEGER()),
(BIGINT, BIGINT()),
(Float, Float()),
(NUMERIC(), ),
(TIMESTAMP, TIMESTAMP()),
(DATETIME, DATETIME()),
(DateTime, DateTime()),
(DateTime(), ),
(DATE, DATE()),
(Date, Date()),
(TIME, TIME()),
(Time, Time()),
(BOOLEAN, BOOLEAN()),
(Boolean, Boolean()),
]
columns = [Column('c%i' % (i + 1), t[0]) for (i, t) in
enumerate(specs)]
db = testing.db
t_table = Table('types', metadata, *columns)
metadata.create_all()
m2 = MetaData(db)
rt = Table('types', m2, autoload=True)
try:
db.execute('CREATE VIEW types_v AS SELECT * from types')
rv = Table('types_v', m2, autoload=True)
expected = [len(c) > 1 and c[1] or c[0] for c in specs]
for table in rt, rv:
for i, reflected in enumerate(table.c):
assert isinstance(reflected.type,
type(expected[i])), '%d: %r' % (i,
type(expected[i]))
finally:
db.execute('DROP VIEW types_v')
class DBFile(BaseModel):
__tablename__ = 'files'
sender_id = Column(
Integer,
ForeignKey('users.id'),
nullable=False,
)
ref_file = Column(VARCHAR(4096))
is_delete = Column(BOOLEAN(), nullable=False, default=False)
class DBMessage(BaseModel):
__tablename__ = "messages"
sender_id = Column(Integer(),
ForeignKey('employees.id', ondelete='CASCADE'),
nullable=False)
recipient_id = Column(Integer(),
ForeignKey('employees.id', ondelete='CASCADE'),
nullable=False)
message = Column(VARCHAR(280)) # Как в Твитторе
is_delete = Column(BOOLEAN(), nullable=False, default=False)
class Device(Base):
"""
Update class that represents a device update
"""
__tablename__ = 'devices'
id: int = Column(INT(),
primary_key=True,
autoincrement=True,
nullable=False)
name: str = Column(VARCHAR(40))
codename: str = Column(VARCHAR(30), nullable=False)
region: str = Column(VARCHAR(30))
miui_name: str = Column(VARCHAR(30))
miui_code: str = Column(VARCHAR(6))
mi_website_id: int = Column(INT())
picture: str = Column(TEXT())
eol: bool = Column(BOOLEAN(), default=False)
firmware_updater = Column(BOOLEAN(), default=True, nullable=False)
def __repr__(self):
return f"<Device(codename={self.codename}, name={self.name}, region={self.region})>"
class Report(db.Model):
__tablename__ = 'reports'
id = Column(INTEGER(11), primary_key=True)
persons_id = Column(ForeignKey('persons.id'), nullable=False, index=True)
campaigns_id = Column(ForeignKey('campaigns.id'),
nullable=False,
index=True)
email_sent = Column(BOOLEAN(4)) #ANTES ERA TINYINT
sms_sent = Column(BOOLEAN(4))
campaigns = relationship('Campaign')
persons = relationship('Person')
def serialize(self):
return {
"id": self.id,
"persons_id": self.persons_id,
"campaigns_id": self.campaigns_id,
"email_sent": self.email_sent,
"sms_sent": self.sms_sent,
}
class Contact(Base):
__tablename__ = 'contact'
id = Column(Integer, primary_key=True, autoincrement=True)
user = Column(String(250), nullable=False)
name = Column(String(250), nullable=False)
phone = Column(BIGINT(), nullable=False)
order = Column(Integer(), nullable=False)
created_time = Column(DateTime(), nullable=False)
modified_time = Column(DateTime(), nullable=False)
is_deleted = Column(BOOLEAN(), nullable=False)
def is_primary(self):
return int(self.order) == ContactOrder.PRIMARY
class DBMessage(BaseModel):
__tablename__ = 'messages'
id = BaseModel.id
created_at = BaseModel.created_at
updated_at = BaseModel.updated_at
message = Column(VARCHAR(200))
sender_id = Column(Integer, nullable=False)
recipient_id = Column(Integer, nullable=False)
is_delete = Column(BOOLEAN(), nullable=False, default=False)
def get_table(metadata):
return Table(
'devices',
metadata,
Column('id',
INT(),
primary_key=True,
autoincrement=True,
nullable=False),
Column('name', VARCHAR(40), nullable=False),
Column('codename',
VARCHAR(30),
nullable=False,
index=True,
onupdate="CASCADE"),
Column('region', VARCHAR(30), nullable=False),
Column('miui_name', VARCHAR(30), nullable=False),
Column('miui_code', VARCHAR(6), nullable=False),
Column('mi_website_id', INT(), nullable=True),
Column('picture', TEXT(), nullable=True),
Column('eol', BOOLEAN(), default=False, nullable=False),
Column('firmware_updater', BOOLEAN(), default=True, nullable=False),
)
class DBMsgFile(BaseModel):
__tablename__ = 'msgs_to_files'
msg_id = Column(
Integer,
ForeignKey('messages.id'),
nullable=False,
)
file_id = Column(
Integer,
ForeignKey('files.id'),
nullable=False,
)
is_delete = Column(BOOLEAN(), nullable=False, default=False)
class Assignment(Base):
'An nbgrader assignment'
__tablename__ = 'assignments'
# in case assignment name needs to be changed
_id = Column(INTEGER, primary_key=True)
id = Column(TEXT)
course_id = Column(INTEGER, ForeignKey('courses._id'))
submissions = relationship('Submission', backref='assignment')
files = relationship('File', secondary=assignment_files_assoc_table)
released = BOOLEAN()
due = Column(TIMESTAMP)
# TODO: timezoon
def __init__(self, name, course):
'Initialize with assignment name and course'
self.id = name
self.course = course
def __str__(self):
return '<Assignment %s>' % self.id
def dump(self):
'Dump data to dict'
return {
'_id': self._id,
'id': self.id,
'course_id': self.course_id,
'released': bool(self.released),
'due': self.due and self.due.strftime('%Y-%m-%d %H:%M:%S.%f %Z'),
}
def delete(self, db):
'Remove assignment and dependent data (files, submissions)'
for file_obj in self.files[:]:
file_obj.delete(db)
self.files.remove(file_obj)
for submission in self.submissions[:]:
submission.delete(db)
self.submissions.remove(submission)
db.delete(self)
class Transaction(Base):
"""Database model to track bank transactions."""
__tablename__ = 'transactions'
t_id = Column(Text(), primary_key=True)
account_id = Column(Text(), nullable=False)
item_id = Column(Text(), nullable=False)
t_type = Column(Text())
t_date = Column(DateTime())
name = Column(Text())
amount = Column(Numeric(12, 2), nullable=False)
category = Column(ARRAY(String))
category_id = Column(Text())
category_uid = Column(Text())
address = Column(Text(), default=None)
city = Column(Text(), default=None)
state = Column(Text(), default=None)
zipcode = Column(Text(), default=None)
pending = Column(BOOLEAN(), default=False)
pending_trans_id = Column(Text(), default=None)
refnum = Column(Text())
class DBProgress(BaseModel):
__tablename__ = 'progress'
queue_id = Column(
Integer,
ForeignKey('videos_queue.id'),
nullable=False,
)
progress_percentage = Column(
Integer,
nullable=False,
)
violations_num = Column(
Integer,
nullable=False,
default=0
)
is_delete = Column(
BOOLEAN(),
nullable=False,
default=False
)
class User(Base):
"""Database model for users."""
__tablename__ = 'users'
id = Column(Text(), primary_key=True)
active = Column(BOOLEAN(), default=True)
balances = Column(JSON)
balances_update = Column(DateTime())
personal = Column(JSON, nullable=False)
personal_update = Column(DateTime())
income = Column(BigInteger())
income_update = Column(DateTime())
spending = Column(JSON)
spending_update = Column(DateTime())
goals = Column(JSON)
goals_update = Column(DateTime())
notices = Column(JSON)
notices_update = Column(DateTime())
categories = Column(JSON)
categories_update = Column(DateTime())
catrules = Column(JSON)
catrules_update = Column(DateTime())
created_on = Column(DateTime(), default=datetime.datetime.utcnow())
class Client(IntId, Migrated, Audited, Base):
name = Column(TextLine, nullable=False)
reduced_fee = Column(types.String(20))
# TODO: phase this out.
note = Column(TEXT())
address = Column(TextLine)
city = Column(types.String(24))
state = Column(types.String(3))
zip = Column(types.String(12))
phone = Column(types.String(15))
DOB = Column(DATE)
Officer_id = Column(INTEGER(),
ForeignKey('Officer.id', ondelete="SET NULL"))
Officer2_id = Column(INTEGER(),
ForeignKey('Officer.id', ondelete="SET NULL"))
Lawyer_id = Column(INTEGER(),
ForeignKey('Officer.id', ondelete="SET NULL"))
Court_id = Column(INTEGER(),
ForeignKey('Office.id', ondelete="SET NULL"))
file = Column(TextCode)
file_site = Column(Enum('op', 'kck'))
file_opened = Column(DATE())
billing_cutoff = Column(DATE())
recent = Column(DATE())
charges = Column(Money)
client_paid = Column(Money)
insurance_paid = Column(Money)
balance = Column(Money)
balance_cached = Column(TIMESTAMP())
invoice_note = Column(TEXT())
voucher = Column(BOOLEAN())
voucher_note = Column(TextLine)
class TypeCompileTest(fixtures.TestBase, AssertsCompiledSQL):
__dialect__ = mysql.dialect()
@testing.combinations(
# column type, args, kwargs, expected ddl
# e.g. Column(Integer(10, unsigned=True)) ==
# 'INTEGER(10) UNSIGNED'
(mysql.MSNumeric, [], {}, "NUMERIC"),
(mysql.MSNumeric, [None], {}, "NUMERIC"),
(mysql.MSNumeric, [12], {}, "NUMERIC(12)"),
(
mysql.MSNumeric,
[12, 4],
{
"unsigned": True
},
"NUMERIC(12, 4) UNSIGNED",
),
(
mysql.MSNumeric,
[12, 4],
{
"zerofill": True
},
"NUMERIC(12, 4) ZEROFILL",
),
(
mysql.MSNumeric,
[12, 4],
{
"zerofill": True,
"unsigned": True
},
"NUMERIC(12, 4) UNSIGNED ZEROFILL",
),
(mysql.MSDecimal, [], {}, "DECIMAL"),
(mysql.MSDecimal, [None], {}, "DECIMAL"),
(mysql.MSDecimal, [12], {}, "DECIMAL(12)"),
(mysql.MSDecimal, [12, None], {}, "DECIMAL(12)"),
(
mysql.MSDecimal,
[12, 4],
{
"unsigned": True
},
"DECIMAL(12, 4) UNSIGNED",
),
(
mysql.MSDecimal,
[12, 4],
{
"zerofill": True
},
"DECIMAL(12, 4) ZEROFILL",
),
(
mysql.MSDecimal,
[12, 4],
{
"zerofill": True,
"unsigned": True
},
"DECIMAL(12, 4) UNSIGNED ZEROFILL",
),
(mysql.MSDouble, [None, None], {}, "DOUBLE"),
(
mysql.MSDouble,
[12, 4],
{
"unsigned": True
},
"DOUBLE(12, 4) UNSIGNED",
),
(
mysql.MSDouble,
[12, 4],
{
"zerofill": True
},
"DOUBLE(12, 4) ZEROFILL",
),
(
mysql.MSDouble,
[12, 4],
{
"zerofill": True,
"unsigned": True
},
"DOUBLE(12, 4) UNSIGNED ZEROFILL",
),
(mysql.MSReal, [None, None], {}, "REAL"),
(mysql.MSReal, [12, 4], {
"unsigned": True
}, "REAL(12, 4) UNSIGNED"),
(mysql.MSReal, [12, 4], {
"zerofill": True
}, "REAL(12, 4) ZEROFILL"),
(
mysql.MSReal,
[12, 4],
{
"zerofill": True,
"unsigned": True
},
"REAL(12, 4) UNSIGNED ZEROFILL",
),
(mysql.MSFloat, [], {}, "FLOAT"),
(mysql.MSFloat, [None], {}, "FLOAT"),
(mysql.MSFloat, [12], {}, "FLOAT(12)"),
(mysql.MSFloat, [12, 4], {}, "FLOAT(12, 4)"),
(mysql.MSFloat, [12, 4], {
"unsigned": True
}, "FLOAT(12, 4) UNSIGNED"),
(mysql.MSFloat, [12, 4], {
"zerofill": True
}, "FLOAT(12, 4) ZEROFILL"),
(
mysql.MSFloat,
[12, 4],
{
"zerofill": True,
"unsigned": True
},
"FLOAT(12, 4) UNSIGNED ZEROFILL",
),
(mysql.MSInteger, [], {}, "INTEGER"),
(mysql.MSInteger, [4], {}, "INTEGER(4)"),
(mysql.MSInteger, [4], {
"unsigned": True
}, "INTEGER(4) UNSIGNED"),
(mysql.MSInteger, [4], {
"zerofill": True
}, "INTEGER(4) ZEROFILL"),
(
mysql.MSInteger,
[4],
{
"zerofill": True,
"unsigned": True
},
"INTEGER(4) UNSIGNED ZEROFILL",
),
(mysql.MSBigInteger, [], {}, "BIGINT"),
(mysql.MSBigInteger, [4], {}, "BIGINT(4)"),
(mysql.MSBigInteger, [4], {
"unsigned": True
}, "BIGINT(4) UNSIGNED"),
(mysql.MSBigInteger, [4], {
"zerofill": True
}, "BIGINT(4) ZEROFILL"),
(
mysql.MSBigInteger,
[4],
{
"zerofill": True,
"unsigned": True
},
"BIGINT(4) UNSIGNED ZEROFILL",
),
(mysql.MSMediumInteger, [], {}, "MEDIUMINT"),
(mysql.MSMediumInteger, [4], {}, "MEDIUMINT(4)"),
(
mysql.MSMediumInteger,
[4],
{
"unsigned": True
},
"MEDIUMINT(4) UNSIGNED",
),
(
mysql.MSMediumInteger,
[4],
{
"zerofill": True
},
"MEDIUMINT(4) ZEROFILL",
),
(
mysql.MSMediumInteger,
[4],
{
"zerofill": True,
"unsigned": True
},
"MEDIUMINT(4) UNSIGNED ZEROFILL",
),
(mysql.MSTinyInteger, [], {}, "TINYINT"),
(mysql.MSTinyInteger, [1], {}, "TINYINT(1)"),
(mysql.MSTinyInteger, [1], {
"unsigned": True
}, "TINYINT(1) UNSIGNED"),
(mysql.MSTinyInteger, [1], {
"zerofill": True
}, "TINYINT(1) ZEROFILL"),
(
mysql.MSTinyInteger,
[1],
{
"zerofill": True,
"unsigned": True
},
"TINYINT(1) UNSIGNED ZEROFILL",
),
(mysql.MSSmallInteger, [], {}, "SMALLINT"),
(mysql.MSSmallInteger, [4], {}, "SMALLINT(4)"),
(
mysql.MSSmallInteger,
[4],
{
"unsigned": True
},
"SMALLINT(4) UNSIGNED",
),
(
mysql.MSSmallInteger,
[4],
{
"zerofill": True
},
"SMALLINT(4) ZEROFILL",
),
(
mysql.MSSmallInteger,
[4],
{
"zerofill": True,
"unsigned": True
},
"SMALLINT(4) UNSIGNED ZEROFILL",
),
)
def test_numeric(self, type_, args, kw, res):
"Exercise type specification and options for numeric types."
type_inst = type_(*args, **kw)
self.assert_compile(type_inst, res)
# test that repr() copies out all arguments
self.assert_compile(eval("mysql.%r" % type_inst), res)
@testing.combinations(
(mysql.MSChar, [1], {}, "CHAR(1)"),
(mysql.NCHAR, [1], {}, "NATIONAL CHAR(1)"),
(mysql.MSChar, [1], {
"binary": True
}, "CHAR(1) BINARY"),
(mysql.MSChar, [1], {
"ascii": True
}, "CHAR(1) ASCII"),
(mysql.MSChar, [1], {
"unicode": True
}, "CHAR(1) UNICODE"),
(
mysql.MSChar,
[1],
{
"ascii": True,
"binary": True
},
"CHAR(1) ASCII BINARY",
),
(
mysql.MSChar,
[1],
{
"unicode": True,
"binary": True
},
"CHAR(1) UNICODE BINARY",
),
(mysql.MSChar, [1], {
"charset": "utf8"
}, "CHAR(1) CHARACTER SET utf8"),
(
mysql.MSChar,
[1],
{
"charset": "utf8",
"binary": True
},
"CHAR(1) CHARACTER SET utf8 BINARY",
),
(
mysql.MSChar,
[1],
{
"charset": "utf8",
"unicode": True
},
"CHAR(1) CHARACTER SET utf8",
),
(
mysql.MSChar,
[1],
{
"charset": "utf8",
"ascii": True
},
"CHAR(1) CHARACTER SET utf8",
),
(
mysql.MSChar,
[1],
{
"collation": "utf8_bin"
},
"CHAR(1) COLLATE utf8_bin",
),
(
mysql.MSChar,
[1],
{
"charset": "utf8",
"collation": "utf8_bin"
},
"CHAR(1) CHARACTER SET utf8 COLLATE utf8_bin",
),
(
mysql.MSChar,
[1],
{
"charset": "utf8",
"binary": True
},
"CHAR(1) CHARACTER SET utf8 BINARY",
),
(
mysql.MSChar,
[1],
{
"charset": "utf8",
"collation": "utf8_bin",
"binary": True
},
"CHAR(1) CHARACTER SET utf8 COLLATE utf8_bin",
),
(mysql.MSChar, [1], {
"national": True
}, "NATIONAL CHAR(1)"),
(
mysql.MSChar,
[1],
{
"national": True,
"charset": "utf8"
},
"NATIONAL CHAR(1)",
),
(
mysql.MSChar,
[1],
{
"national": True,
"charset": "utf8",
"binary": True
},
"NATIONAL CHAR(1) BINARY",
),
(
mysql.MSChar,
[1],
{
"national": True,
"binary": True,
"unicode": True
},
"NATIONAL CHAR(1) BINARY",
),
(
mysql.MSChar,
[1],
{
"national": True,
"collation": "utf8_bin"
},
"NATIONAL CHAR(1) COLLATE utf8_bin",
),
(
mysql.MSString,
[1],
{
"charset": "utf8",
"collation": "utf8_bin"
},
"VARCHAR(1) CHARACTER SET utf8 COLLATE utf8_bin",
),
(
mysql.MSString,
[1],
{
"national": True,
"collation": "utf8_bin"
},
"NATIONAL VARCHAR(1) COLLATE utf8_bin",
),
(
mysql.MSTinyText,
[],
{
"charset": "utf8",
"collation": "utf8_bin"
},
"TINYTEXT CHARACTER SET utf8 COLLATE utf8_bin",
),
(
mysql.MSMediumText,
[],
{
"charset": "utf8",
"binary": True
},
"MEDIUMTEXT CHARACTER SET utf8 BINARY",
),
(mysql.MSLongText, [], {
"ascii": True
}, "LONGTEXT ASCII"),
(
mysql.ENUM,
["foo", "bar"],
{
"unicode": True
},
"""ENUM('foo','bar') UNICODE""",
),
(String, [20], {
"collation": "utf8"
}, "VARCHAR(20) COLLATE utf8"),
)
@testing.exclude("mysql", "<", (4, 1, 1), "no charset support")
def test_charset(self, type_, args, kw, res):
"""Exercise CHARACTER SET and COLLATE-ish options on string types."""
type_inst = type_(*args, **kw)
self.assert_compile(type_inst, res)
@testing.combinations(
(mysql.MSBit(), "BIT"),
(mysql.MSBit(1), "BIT(1)"),
(mysql.MSBit(63), "BIT(63)"),
)
def test_bit_50(self, type_, expected):
"""Exercise BIT types on 5.0+ (not valid for all engine types)"""
self.assert_compile(type_, expected)
@testing.combinations(
(BOOLEAN(), "BOOL"),
(Boolean(), "BOOL"),
(mysql.TINYINT(1), "TINYINT(1)"),
(mysql.TINYINT(1, unsigned=True), "TINYINT(1) UNSIGNED"),
)
def test_boolean_compile(self, type_, expected):
self.assert_compile(type_, expected)
def test_timestamp_fsp(self):
self.assert_compile(mysql.TIMESTAMP(fsp=5), "TIMESTAMP(5)")
@testing.combinations(
([TIMESTAMP], {}, "TIMESTAMP NULL"),
([mysql.MSTimeStamp], {}, "TIMESTAMP NULL"),
(
[
mysql.MSTimeStamp(),
DefaultClause(sql.text("CURRENT_TIMESTAMP")),
],
{},
"TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP",
),
(
[mysql.MSTimeStamp,
DefaultClause(sql.text("CURRENT_TIMESTAMP"))],
{
"nullable": False
},
"TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP",
),
(
[
mysql.MSTimeStamp,
DefaultClause(sql.text("'1999-09-09 09:09:09'")),
],
{
"nullable": False
},
"TIMESTAMP NOT NULL DEFAULT '1999-09-09 09:09:09'",
),
(
[
mysql.MSTimeStamp(),
DefaultClause(sql.text("'1999-09-09 09:09:09'")),
],
{},
"TIMESTAMP NULL DEFAULT '1999-09-09 09:09:09'",
),
(
[
mysql.MSTimeStamp(),
DefaultClause(
sql.text("'1999-09-09 09:09:09' "
"ON UPDATE CURRENT_TIMESTAMP")),
],
{},
"TIMESTAMP NULL DEFAULT '1999-09-09 09:09:09' "
"ON UPDATE CURRENT_TIMESTAMP",
),
(
[
mysql.MSTimeStamp,
DefaultClause(
sql.text("'1999-09-09 09:09:09' "
"ON UPDATE CURRENT_TIMESTAMP")),
],
{
"nullable": False
},
"TIMESTAMP NOT NULL DEFAULT '1999-09-09 09:09:09' "
"ON UPDATE CURRENT_TIMESTAMP",
),
(
[
mysql.MSTimeStamp(),
DefaultClause(
sql.text("CURRENT_TIMESTAMP "
"ON UPDATE CURRENT_TIMESTAMP")),
],
{},
"TIMESTAMP NULL DEFAULT CURRENT_TIMESTAMP "
"ON UPDATE CURRENT_TIMESTAMP",
),
(
[
mysql.MSTimeStamp,
DefaultClause(
sql.text("CURRENT_TIMESTAMP "
"ON UPDATE CURRENT_TIMESTAMP")),
],
{
"nullable": False
},
"TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP "
"ON UPDATE CURRENT_TIMESTAMP",
),
)
def test_timestamp_defaults(self, spec, kw, expected):
"""Exercise funky TIMESTAMP default syntax when used in columns."""
c = Column("t", *spec, **kw)
Table("t", MetaData(), c)
self.assert_compile(schema.CreateColumn(c), "t %s" % expected)
def test_datetime_generic(self):
self.assert_compile(mysql.DATETIME(), "DATETIME")
def test_datetime_fsp(self):
self.assert_compile(mysql.DATETIME(fsp=4), "DATETIME(4)")
def test_time_generic(self):
""""Exercise TIME."""
self.assert_compile(mysql.TIME(), "TIME")
def test_time_fsp(self):
self.assert_compile(mysql.TIME(fsp=5), "TIME(5)")
def test_time_result_processor(self):
eq_(
mysql.TIME().result_processor(None, None)(datetime.timedelta(
seconds=35, minutes=517, microseconds=450)),
datetime.time(8, 37, 35, 450),
)
