def get_distribution(benchmark_result, limit): from ..entities.benchmark_result import BenchmarkResult commits_up = (get_commits_up(benchmark_result.run.commit, limit).subquery().alias("commits_up")) return (Session.query( func.text(benchmark_result.case_id).label("case_id"), func.text(benchmark_result.context_id).label("context_id"), func.text(benchmark_result.run.commit_id).label("commit_id"), Hardware.hash.label("hash"), func.max(BenchmarkResult.unit).label("unit"), func.avg(BenchmarkResult.mean).label("mean_mean"), func.stddev(BenchmarkResult.mean).label("mean_sd"), func.avg(BenchmarkResult.min).label("min_mean"), func.stddev(BenchmarkResult.min).label("min_sd"), func.avg(BenchmarkResult.max).label("max_mean"), func.stddev(BenchmarkResult.max).label("max_sd"), func.avg(BenchmarkResult.median).label("median_mean"), func.stddev(BenchmarkResult.median).label("median_sd"), func.min(commits_up.c.timestamp).label("first_timestamp"), func.max(commits_up.c.timestamp).label("last_timestamp"), func.count(BenchmarkResult.mean).label("observations"), ).group_by( BenchmarkResult.case_id, BenchmarkResult.context_id, Hardware.hash, ).join(Run, Run.id == BenchmarkResult.run_id).join( Hardware, Hardware.id == Run.hardware_id).join( commits_up, commits_up.c.id == Run.commit_id).filter( Run.name.like("commit: %"), BenchmarkResult.case_id == benchmark_result.case_id, BenchmarkResult.context_id == benchmark_result.context_id, Hardware.hash == benchmark_result.run.hardware.hash, ))
def get_requests(): """ Get all project requests """ filters = [] if 'project_name' in request.args: filters.append(Request.project_name == request.args['project_name']) if 'reference_id' in request.args: filters.append(func.text(Request.reference_id) == request.args['reference_id']) all_requests = flask.g.session.query(Request, User.username ).join(User, Request.user_id == User.id ).filter(*filters ).order_by(case(((Request.status == 'pending', 1), (Request.status == 'approved', 2), (Request.status == 'declined', 3))) ).all() requests = [] row2dict = lambda row: { column.name: str(getattr(row, column.name)) for column in row.__table__.columns if column.name in ['reference_id', 'project_name', 'status', 'project_desc'] } for req, requested_by in all_requests: request_obj = row2dict(req) request_obj['requested_by'] = requested_by requests.append(request_obj) return jsonify({'message': 'success', 'requests': requests}), 200
class Human(Base): ''' Human accesses the Association as a One to Many relationship ''' __tablename__ = 'humans' id = Column(Integer, primary_key=True) name = Column(String) carsAssoc = relationship('HumanCarAssociation') e = func.date_add(func.now(), bindparam('e', func.text('INTERVAL 5 day')))
def hashed_uid_factory(request): if request.matchdict is not None and 'hash' in request.matchdict: context = models.TalkPreference.query.filter( func.encode( func.digest(func.text(models.TalkPreference.uid), 'sha256'), 'hex') == request.matchdict['hash']).first() if context is None: raise NotFound() return context return object()
def postgresql_non_ascii_and_lower(column, as_text=True): if hasattr(column, 'property'): columns = column.property.columns if len(columns) > 1: column = func.concat(*columns) else: column = column.property.columns[0] if isinstance(column.type, Enum): return column elif isinstance(column.type, String): return func.lower_and_clear(column) elif isinstance(column.type, Numeric): return column elif as_text: return func.text(column) else: return column
def test_namespacing_conflicts(self): self.assert_compile(func.text('foo'), 'text(:text_1)')
def test_namespacing_conflicts(self): self.assert_compile(func.text("foo"), "text(:text_1)")
.join(Host.interfaces) .join(Host.room) .join(Room.connected_patch_ports) .join(SwitchPort) .join(Switch) .statement, ), ) hades_view_ddl.add_view(radius_property, radusergroup) radcheck = View( name='radcheck', query=( # This adds all existing interfaces. Query([ func.text(Interface.mac).label('UserName'), func.host(Switch.management_ip).label('NASIPAddress'), SwitchPort.name.label('NASPortId'), literal("User-Name").label('Attribute'), literal("=*").label('Op'), null().label('Value'), literal(10).label('Priority'), ]).select_from(Interface) .join(Host) .join(Room) .join(Room.connected_patch_ports) .join(SwitchPort) .join(Switch) .statement ), )
def test_get_talk_by_hashed_uid(models, talk_preference): from sqlalchemy import func assert models.TalkPreference.query.filter( func.encode(func.digest(func.text(models.TalkPreference.uid), 'sha256'), 'hex') == talk_preference.hashed_uid).one() == talk_preference
def get_distribution( summary_table, run_table, machine_table, commit_table, commit, summary, machine_hash, limit, ): commits_up = ( get_commits_up(commit_table, commit, limit).subquery().alias("commits_up") ) return ( select( func.text(summary.case_id).label("case_id"), func.text(summary.context_id).label("context_id"), func.text(commit.id).label("commit_id"), func.concat( machine_table.c.name, "-", machine_table.c.gpu_count, "-", machine_table.c.cpu_core_count, "-", machine_table.c.cpu_thread_count, "-", machine_table.c.memory_bytes, ).label("hash"), func.max(summary_table.c.unit).label("unit"), func.avg(summary_table.c.mean).label("mean_mean"), func.stddev(summary_table.c.mean).label("mean_sd"), func.avg(summary_table.c.min).label("min_mean"), func.stddev(summary_table.c.min).label("min_sd"), func.avg(summary_table.c.max).label("max_mean"), func.stddev(summary_table.c.max).label("max_sd"), func.avg(summary_table.c.median).label("median_mean"), func.stddev(summary_table.c.median).label("median_sd"), func.min(commits_up.c.timestamp).label("first_timestamp"), func.max(commits_up.c.timestamp).label("last_timestamp"), func.count(summary_table.c.mean).label("observations"), ) .group_by( summary_table.c.case_id, summary_table.c.context_id, machine_table.c.name, machine_table.c.gpu_count, machine_table.c.cpu_core_count, machine_table.c.cpu_thread_count, machine_table.c.memory_bytes, ) .join(run_table, run_table.c.id == summary_table.c.run_id) .join(machine_table, machine_table.c.id == run_table.c.machine_id) .join(commits_up, commits_up.c.id == run_table.c.commit_id) .filter( run_table.c.name.like("commit: %"), summary_table.c.case_id == summary.case_id, summary_table.c.context_id == summary.context_id, func.concat( machine_table.c.name, "-", machine_table.c.gpu_count, "-", machine_table.c.cpu_core_count, "-", machine_table.c.cpu_thread_count, "-", machine_table.c.memory_bytes, ) == machine_hash, ) )
def test_get_talk_by_hashed_uid(models, talk_preference): from sqlalchemy import func assert models.TalkPreference.query.filter(func.encode(func.digest(func.text(models.TalkPreference.uid), 'sha256'), 'hex') == talk_preference.hashed_uid).one() == talk_preference