def test_can_get_fields_backed_by_expressions():
Base = sqlalchemy.ext.declarative.declarative_base()
class BookRow(Base):
__tablename__ = "book"
c_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_title = sqlalchemy.Column(sqlalchemy.Unicode, nullable=False)
engine = sqlalchemy.create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
session = sqlalchemy.orm.Session(engine)
session.add(BookRow(c_title="Leave it to Psmith"))
session.add(BookRow(c_title="Pericles, Prince of Tyre"))
session.commit()
Book = g.ObjectType(
"Book",
fields=lambda: [
g.field("title", type=g.String),
],
)
book_resolver = gsql.sql_table_resolver(
Book,
BookRow,
fields={
Book.fields.title: gsql.expression(BookRow.c_title),
},
)
resolvers = [book_resolver]
query = gsql.select(
g.ListType(Book)(g.key("title", Book.fields.title()), ))
graph_definition = g.define_graph(resolvers)
graph = graph_definition.create_graph({
sqlalchemy.orm.Session: session,
})
result = graph.resolve(query)
assert_that(
result,
contains_exactly(
has_attrs(title="Leave it to Psmith", ),
has_attrs(title="Pericles, Prince of Tyre", ),
))
def test_can_pass_arguments_to_expression():
Base = sqlalchemy.ext.declarative.declarative_base()
class BookRow(Base):
__tablename__ = "book"
c_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_title = sqlalchemy.Column(sqlalchemy.Unicode, nullable=False)
engine = sqlalchemy.create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
session = sqlalchemy.orm.Session(engine)
session.add(BookRow(c_title="Leave it to Psmith"))
session.commit()
Book = g.ObjectType(
"Book",
fields=lambda: [
g.field(
"title", type=g.String, params=[
g.param("truncate", g.Int),
]),
],
)
book_resolver = gsql.sql_table_resolver(
Book,
BookRow,
fields={
Book.fields.title:
lambda args: gsql.expression(
sqlalchemy.func.substr(BookRow.c_title, 1, args.truncate)),
},
)
resolvers = [book_resolver]
query = gsql.select(
g.ListType(Book)(g.key(
"title",
Book.fields.title(Book.fields.title.params.truncate(8))), ))
graph_definition = g.define_graph(resolvers)
graph = graph_definition.create_graph({sqlalchemy.orm.Session: session})
result = graph.resolve(query)
assert_that(result, contains_exactly(has_attrs(title="Leave it", ), ))
def select(type_query):
return gsql.select(type_query)
def root_resolve_books(graph, query, args):
return graph.resolve(gsql.select(query))
def select_by_molregno(query, molregnos):
return gsql.select(query).by(database.MoleculeSynonym.molregno, molregnos)
def select(query):
return gsql.select(query)
def test_can_join_tables_using_multi_column_key():
Base = sqlalchemy.ext.declarative.declarative_base()
class LeftRow(Base):
__tablename__ = "left"
c_id_1 = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_id_2 = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_value = sqlalchemy.Column(sqlalchemy.Unicode)
class RightRow(Base):
__tablename__ = "right"
c_id_1 = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_id_2 = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_value = sqlalchemy.Column(sqlalchemy.Unicode)
engine = sqlalchemy.create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
session = sqlalchemy.orm.Session(engine)
session.add(LeftRow(c_id_1=1, c_id_2=2, c_value="one"))
session.add(RightRow(c_id_1=1, c_id_2=2, c_value="two"))
session.add(LeftRow(c_id_1=1, c_id_2=3, c_value="three"))
session.add(RightRow(c_id_1=1, c_id_2=3, c_value="four"))
session.commit()
Left = g.ObjectType(
"Left",
fields=lambda: [
g.field("value", type=g.String),
g.field("right", type=Right),
],
)
Right = g.ObjectType(
"Right",
fields=lambda: [
g.field("value", type=g.String),
],
)
left_resolver = gsql.sql_table_resolver(
Left,
LeftRow,
fields={
Left.fields.value:
gsql.expression(LeftRow.c_value),
Left.fields.right:
g.single(
gsql.sql_join({
LeftRow.c_id_1: RightRow.c_id_1,
LeftRow.c_id_2: RightRow.c_id_2,
})),
},
)
right_resolver = gsql.sql_table_resolver(
Right,
RightRow,
fields={
Right.fields.value: gsql.expression(RightRow.c_value),
},
)
resolvers = [left_resolver, right_resolver]
query = gsql.select(
g.ListType(Left)(
g.key("value", Left.fields.value()),
g.key("right",
Left.fields.right(g.key("value", Right.fields.value()), )),
))
graph_definition = g.define_graph(resolvers)
graph = graph_definition.create_graph({sqlalchemy.orm.Session: session})
result = graph.resolve(query)
assert_that(
result,
contains_exactly(
has_attrs(
value="one",
right=has_attrs(value="two", ),
),
has_attrs(
value="three",
right=has_attrs(value="four", ),
),
))
def test_can_resolve_join_through_association_table():
Base = sqlalchemy.ext.declarative.declarative_base()
class LeftRow(Base):
__tablename__ = "left"
c_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_value = sqlalchemy.Column(sqlalchemy.Unicode)
class AssociationRow(Base):
__tablename__ = "association"
c_left_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_right_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
class RightRow(Base):
__tablename__ = "right"
c_id = sqlalchemy.Column(sqlalchemy.Integer, primary_key=True)
c_value = sqlalchemy.Column(sqlalchemy.Unicode)
engine = sqlalchemy.create_engine("sqlite:///:memory:")
Base.metadata.create_all(engine)
session = sqlalchemy.orm.Session(engine)
session.add(LeftRow(c_id=1, c_value="left 1"))
session.add(RightRow(c_id=101, c_value="right 1a"))
session.add(RightRow(c_id=102, c_value="right 1b"))
session.add(AssociationRow(c_left_id=1, c_right_id=101))
session.add(AssociationRow(c_left_id=1, c_right_id=102))
session.add(LeftRow(c_id=2, c_value="left 2"))
session.add(LeftRow(c_id=3, c_value="left 3"))
session.add(RightRow(c_id=103, c_value="right 3"))
session.add(AssociationRow(c_left_id=3, c_right_id=103))
session.commit()
Left = g.ObjectType(
"Left",
fields=lambda: [
g.field("value", type=g.String),
g.field("rights", type=g.ListType(Right)),
],
)
Right = g.ObjectType(
"Right",
fields=lambda: [
g.field("value", type=g.String),
],
)
left_resolver = gsql.sql_table_resolver(
Left,
LeftRow,
fields={
Left.fields.value:
gsql.expression(LeftRow.c_value),
Left.fields.rights:
g.many(
gsql.sql_join(
{LeftRow.c_id: AssociationRow.c_left_id},
AssociationRow,
{AssociationRow.c_right_id: RightRow.c_id},
)),
},
)
right_resolver = gsql.sql_table_resolver(
Right,
RightRow,
fields={
Right.fields.value: gsql.expression(RightRow.c_value),
},
)
resolvers = [left_resolver, right_resolver]
query = gsql.select(
g.ListType(Left)(
g.key("value", Left.fields.value()),
g.key("rights",
Left.fields.rights(g.key("value", Right.fields.value()), )),
))
graph_definition = g.define_graph(resolvers)
graph = graph_definition.create_graph({sqlalchemy.orm.Session: session})
result = graph.resolve(query)
assert_that(
result,
contains_exactly(
has_attrs(
value="left 1",
rights=contains_exactly(
has_attrs(value="right 1a"),
has_attrs(value="right 1b"),
),
),
has_attrs(
value="left 2",
rights=contains_exactly(),
),
has_attrs(
value="left 3",
rights=contains_exactly(has_attrs(value="right 3"), ),
),
))