def test_const_expr_role(self): t = true() is_(expect(roles.ConstExprRole, t), t) f = false() is_(expect(roles.ConstExprRole, f), f) is_instance_of(expect(roles.ConstExprRole, True), True_) is_instance_of(expect(roles.ConstExprRole, False), False_) is_instance_of(expect(roles.ConstExprRole, None), Null)
def test_anonymized_from_clause_role(self): is_true(expect(roles.AnonymizedFromClauseRole, t).compare(t.alias())) # note the compare for subquery().alias(), even if it is two # plain Alias objects (which it won't be once we introduce the # Subquery class), still compares based on alias() being present # twice, that is, alias().alias() builds an alias of an alias, rather # than just replacing the outer alias. is_true( expect( roles.AnonymizedFromClauseRole, select([t]).subquery() ).compare(select([t]).subquery().alias()) )
def test_strict_from_clause_role(self): stmt = select([t]).subquery() is_true( expect(roles.StrictFromClauseRole, stmt).compare( select([t]).subquery() ) )
def test_labeled_role(self): stmt = select([table1.c.myid]) with testing.expect_deprecated( "coercing SELECT object to scalar " "subquery in a column-expression context is deprecated" ): coerced = coercions.expect(roles.LabeledColumnExprRole, stmt) is_true(coerced.compare(stmt.scalar_subquery().label(None))) with testing.expect_deprecated( "coercing SELECT object to scalar " "subquery in a column-expression context is deprecated" ): coerced = coercions.expect( roles.LabeledColumnExprRole, stmt.alias() ) is_true(coerced.compare(stmt.scalar_subquery().label(None)))
def test_fromclause_subquery(self): stmt = select([table1.c.myid]) with testing.expect_deprecated( "Implicit coercion of SELECT and textual SELECT constructs " "into FROM clauses is deprecated" ): coerced = coercions.expect( roles.StrictFromClauseRole, stmt, allow_select=True ) is_true(coerced.compare(stmt.subquery()))
def test_labeled_column_expr_role(self): c = column("q") is_true(expect(roles.LabeledColumnExprRole, c).compare(c)) is_true( expect(roles.LabeledColumnExprRole, c.label("foo")).compare( c.label("foo") ) ) is_true( expect( roles.LabeledColumnExprRole, select([column("q")]).scalar_subquery(), ).compare(select([column("q")]).label(None)) ) is_true( expect(roles.LabeledColumnExprRole, not_a_thing1).compare( literal(not_a_thing1).label(None) ) )
def test_column_roles(self): stmt = select([table1.c.myid]) for role in [ roles.WhereHavingRole, roles.ExpressionElementRole, roles.ByOfRole, roles.OrderByRole, # roles.LabeledColumnExprRole ]: with testing.expect_deprecated( "coercing SELECT object to scalar " "subquery in a column-expression context is deprecated" ): coerced = coercions.expect(role, stmt) is_true(coerced.compare(stmt.scalar_subquery())) with testing.expect_deprecated( "coercing SELECT object to scalar " "subquery in a column-expression context is deprecated" ): coerced = coercions.expect(role, stmt.alias()) is_true(coerced.compare(stmt.scalar_subquery()))
def __init__(self, expression): self.clause = coercions.expect(roles.ExpressionElementRole, expression)
def test_statement_text_coercion(self): with testing.expect_deprecated_20( "Using plain strings to indicate SQL statements"): is_true( expect(roles.StatementRole, "select * from table").compare( text("select * from table")))
def visit_create_index(self, create): preparer = self.preparer index = create.element self._verify_index_table(index) text = "CREATE " if index.unique: distributed_by = index.table.dialect_options['greenplum'][ 'distributed_by'] # logger.info('table_cols={}'.format(str(index.table.columns))) if distributed_by is None: primary_key_cols = [c.name for c in index.table.primary_key] logger.info('primary_key_cols={}'.format( str(primary_key_cols))) distributed_by_cols = primary_key_cols if len(distributed_by_cols) == 0: distributed_by_cols = [index.table.columns[0]] elif distributed_by == 'RANDOM': distributed_by_cols = [] else: distributed_by_cols = distributed_by.split(',') logger.info('distributed_by_cols={}'.format( str(distributed_by_cols))) index_cols = [c.name for c in index.columns] logger.info('index_cols={}'.format(str(index_cols))) if set(index_cols).issuperset(set(distributed_by_cols)): text += "UNIQUE " text += "INDEX " if self.dialect._supports_create_index_concurrently: concurrently = index.dialect_options['greenplum']['concurrently'] if concurrently: text += "CONCURRENTLY " text += "%s ON %s " % (self._prepared_index_name( index, include_schema=False), preparer.format_table(index.table)) using = index.dialect_options['greenplum']['using'] if using: text += ("USING %s " % self.preparer.validate_sql_phrase( using, base.IDX_USING).lower()) ops = index.dialect_options["greenplum"]["ops"] text += "(%s)" \ % ( ', '.join([ self.sql_compiler.process( expr.self_group() if not isinstance(expr, expression.ColumnClause) else expr, include_table=False, literal_binds=True, ) + ( (' ' + ops[expr.key]) if hasattr(expr, 'key') and expr.key in ops else '' ) for expr in index.expressions ]) ) withclause = index.dialect_options['greenplum']['with'] if withclause: text += " WITH (%s)" % (', '.join([ '%s = %s' % storage_parameter for storage_parameter in withclause.items() ])) tablespace_name = index.dialect_options['greenplum']['tablespace'] if tablespace_name: text += " TABLESPACE %s" % preparer.quote(tablespace_name) whereclause = index.dialect_options["greenplum"]["where"] if whereclause is not None: whereclause = coercions.expect(roles.DDLExpressionRole, whereclause) where_compiled = self.sql_compiler.process( whereclause, include_table=False, literal_binds=True, ) text += " WHERE " + where_compiled return text
def test_statement_coercion_sequence(self): s1 = Sequence("hi") is_(expect(roles.CoerceTextStatementRole, s1), s1)
def test_columns_clause_role(self): is_(expect(roles.ColumnsClauseRole, t.c.q), t.c.q)
def test_statement_coercion_ddl(self): d1 = DDL("hi") is_(expect(roles.CoerceTextStatementRole, d1), d1)
def test_statement_text_coercion(self): is_true( expect(roles.CoerceTextStatementRole, "select * from table").compare(text("select * from table")))
def test_strict_from_clause_role(self): stmt = select(t).subquery() is_true( expect(roles.StrictFromClauseRole, stmt).compare(select(t).subquery()))
def test_text_as_from_select_statement(self): is_true( expect( roles.SelectStatementRole, text("select * from table").columns(t.c.q), ).compare(text("select * from table").columns(t.c.q)))
def go(x): return coercions.expect(roles.WhereHavingRole, lambda: t1.c.q == x)
def test_truncated_label_role(self): is_instance_of( expect(roles.TruncatedLabelRole, "foobar"), _truncated_label )
def test_truncated_label_role(self): is_instance_of(expect(roles.TruncatedLabelRole, "foobar"), _truncated_label)
def test_statement_text_coercion(self): is_true( expect( roles.CoerceTextStatementRole, "select * from table" ).compare(text("select * from table")) )
def test_statement_coercion_select(self): is_true( expect(roles.CoerceTextStatementRole, select(t)).compare(select(t)))
def test_statement_coercion_select(self): is_true( expect(roles.CoerceTextStatementRole, select([t])).compare( select([t]) ) )