Python Query.where方法代码示例

# 需要导入模块: from query import Query [as 别名]
# 或者: from query.Query import where [as 别名]
def find(cls, limit=1000, where=None, order="", operator_where=Query.AND):
    where = where or {}
    q = Query(cls).select('*')
    deleted_keys = []

    for key in where:
        values = where[key]

        # example of usages:
        # .find(Person, where={'code_language': (Query.IN, ['ruby', 'python']))
        if isinstance(values, tuple):
            val = values[1]
            if isinstance(values[1], list):
                val = tuple(values[1])
            q = q.where({key: val}, values[0])
            deleted_keys.append(key)

    for key in deleted_keys:
        del where[key]

    q.where(where, operator_where=operator_where).limit(limit).order(order)
    result = query(q)
    if cls.__name__ in result:
        return result[cls.__name__]
    return []

# 需要导入模块: from query import Query [as 别名]
# 或者: from query.Query import where [as 别名]
 def test_where_does_not_mutate_query(self):
     with mock.patch("query.Repo") as Repo:
         q = Query(TunaCasserole).where(my_attr=5)
         q.where(my_attr=3)
         list(q)
         repo = Repo.return_value
         repo.where.assert_called_with([], my_attr=5)
         repo.where.return_value.select.assert_called_with(
             "id", "created_at", "updated_at", "my_attr")

# 需要导入模块: from query import Query [as 别名]
# 或者: from query.Query import where [as 别名]
 def load(self):
     query = Query(self._connection)
     query.SELECT("gid", self.name)
     query.SELECT("the_geom", self.name, "AsText")
     query.SELECT(self._primary, self.name)
     for key, gen in self._fields:
         query.SELECT(key, self.name)
     whereList = []
     try:
         for entry in self._subset:
             item = self.name + "." + self._primary + "='" + entry + "'"
             whereList.append(item)
             query.where = " OR ".join(whereList)
     except TypeError:
         pass
     polyDict = PolygonDictionary()
     pairs = []
     for entry in query:
         d = []
         for key, gen in self._fields:
             d.append((gen, entry[key]))
         data = Dictionary()
         data.update(d)
         p = GeneralizedPolygon(enum.ABSTRACT, entry["gid"], entry["the_geom"], data, self)
         polyKey = keygen(entry[self._primary])
         pairs.append((polyKey, p))
     polyDict.update(pairs)
     return polyDict

# 需要导入模块: from query import Query [as 别名]
# 或者: from query.Query import where [as 别名]
def test_update():
    data = {'col1': 'val1',
            'col2': 'val2',}
    query = Query('Movies').update(data).where('movieID', 'key1', '=', True)
    assert query.execute().strip() == "UPDATE Movies SET col2 = val2, col1 = val1 WHERE movieID = key1"

    data = {'user_name': "'bob'"}

    query = Query('clicks', 'excelsior').update(data).where('userid', 'cfd66ccc-d857', '=', True).ttl(432000)
    assert query.execute().strip() == "UPDATE excelsior.clicks USING TTL 432000 SET user_name = 'bob' " \
                                      "WHERE userid = cfd66ccc-d857"

    data = {'total': 'total + 2'}
    query = Query('UserActionCounts').update(data).where('keyalias', 523)
    assert query.execute().strip() == "UPDATE UserActionCounts SET total = total + 2 WHERE keyalias = 523"

    data = {'user_name': "'bob'"}
    query = Query('clicks', 'excelsior').update(data).where('userid', 'cfd66ccc-d857-4e90-b1e5-df98a3d40cd6', '=', True)
    query.where('url', 'http://google.com').ttl(432000)
    assert query.execute().strip() == "UPDATE excelsior.clicks USING TTL 432000 SET user_name = 'bob' " \
                                      "WHERE userid = cfd66ccc-d857-4e90-b1e5-df98a3d40cd6 AND url = 'http://google.com'"

    data = {'col3': 'val3'}
    query = Query('Movies').update(data).where('movieID', '(key1, key2, key3)', 'IN', True)
    assert query.execute().strip() == "UPDATE Movies SET col3 = val3 WHERE movieID IN (key1, key2, key3)"

    data = {'state': "'TX'"}
    query = Query('users').update(data).where('user_uuid', '(88b8fd18-b1ed-4e96-bf79-4280797cba80, '
                                                           '06a8913c-c0d6-477c-937d-6c1b69a95d43, '
                                                           'bc108776-7cb5-477f-917d-869c12dfffa8)', 'IN', True)
    assert query.execute().strip() == "UPDATE users SET state = 'TX' " \
                                      "WHERE user_uuid IN (88b8fd18-b1ed-4e96-bf79-4280797cba80, " \
                                      "06a8913c-c0d6-477c-937d-6c1b69a95d43, bc108776-7cb5-477f-917d-869c12dfffa8)"

    data = {'col4': 22}
    query = Query('Movies').update(data).where('movieID', 'key4', '=', True)
    assert query.execute().strip() == "UPDATE Movies SET col4 = 22 WHERE movieID = key4"



    """

# 需要导入模块: from query import Query [as 别名]
# 或者: from query.Query import where [as 别名]
class Layer:
  def __init__(self, layer_name_prefix, layer_node):
    self.layer_node = layer_node
    self.type = self.layer_node.attrib["type"]
    self.id = int(self.layer_node.attrib["id"])
    self.layer_name = layer_name_prefix + str(self.id)

    d = self.layer_node.find("DATASET")
    if d is not None:
      self.dataset_name = d.attrib["name"].lower()
      self.dataset_type = d.attrib["type"].lower()

    if self.type == "featureclass":
      q = self.layer_node.find("QUERY")
      if q is not None:
        self.query = Query(q)

    self.renderers = []
    simple_renderer_nodes = self.layer_node.findall(".//SIMPLERENDERER")
    self.renderers += [SimpleRenderer(node) for node in simple_renderer_nodes]
    value_map_renderer_nodes = self.layer_node.findall(".//VALUEMAPRENDERER")
    self.renderers += [ValueMapRenderer(node) for node in value_map_renderer_nodes]

  def to_sql(self):
    q = "-- LAYER NAME \"{0}\"\nSELECT *".format(self.layer_name)

    # FROM
    tables = []
    if hasattr(self, "dataset_name"):
      tables += [self.dataset_name]
    if hasattr(self, "query"):
      tables += [self.query.tables()]
    if len(tables) == 0:
      return False
    q += " FROM " + ", ".join(["\"{}\"".format(t) for t in tables])

    # WHERE
    if hasattr(self, "query"):
      q += " WHERE {0}".format(self.query.where())

    return q# + ";"

  def to_css(self):
    css = "/* LAYER NAME {0} */\n".format(self.layer_name)
    for renderer in self.renderers:
      css += renderer.to_css()
    return css

  def to_sld(self):
    sld = ET.Element("StyledLayerDescriptor")
    sld.attrib["version"] = "1.0.0"
    sld.attrib["xsi:schemaLocation"] = "http://www.opengis.net/sld StyledLayerDescriptor.xsd"
    sld.attrib["xmlns"] = "http://www.opengis.net/sld"
    sld.attrib["xmlns:ogc"] = "http://www.opengis.net/ogc"
    sld.attrib["xmlns:xlink"] = "http://www.w3.org/1999/xlink"
    sld.attrib["xmlns:xsi"] = "http://www.w3.org/2001/XMLSchema-instance"

    named_layer = ET.SubElement(sld, "NamedLayer")
    name = ET.SubElement(named_layer, "Name")
    name.text = self.layer_name
    user_style = ET.SubElement(named_layer, "UserStyle")

    feature_type_style = ET.SubElement(user_style, "FeatureTypeStyle")
    for renderer in self.renderers:
      feature_type_style.extend(list(renderer.to_sld()))

    return pretty_xml(sld)

  def to_axl(self):
    return pretty_xml(self.layer_node)