Python query.Query类代码示例

def textBasedUi ( ):
    """
    Offers 6 options to user. Handles input errors.
    """

    userChoice = 0
    query = Query( pIndex )
    userInput = ""
    cosines = 0 #Value for list of cosine values for page ranking

    while userInput != 'quit':
        print("Enter a query, type (quit) to exit")
        userInput = getWord()
        userInput = ' '.join(userInput) #convert list of normalized words from user input into single string
        if queryWeight == 'nnn':
            print("Weighting Query: NNN")
            qWeights = queryNNN(userInput)
            cosines = scoring(qWeights)
        else:
            print("Weighting Query: LTC")
            qWeights = queryLTC(userInput)
            cosines = scoring(qWeights)
        if userInput != 'quit':
            displayResults(query.stringQuery(userInput), cosines)
    print("QUITTING")
    '''

def run(port, name, config):
    STUB_RESPONSE = '0.0.0.0'

    try:
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.bind(('',port))
    except Exception as e:
        print 'failed to create socket %s' % e
        sys.exit(1)

    print 'Running dns server'

    try:
        while 1:
            data, addr = s.recvfrom(1024)
            p=Query(data)
            # if host is our cdn target
            if name in p.domain:
                response = handle_response(addr[0], config)
            else:
                response = p.question(p.domain)
                if not response: # couldn't find host
                    response = STUB_RESPONSE
            s.sendto(p.answer(response), addr)
            print '%s -> %s' % (p.domain, response)
    except KeyboardInterrupt:
        print 'Keyboard Interrupt'
        s.close()

def main():
    args = docopt(__doc__)
    sql_str = args['SQL'] or sys.stdin.read()
    debug = args['--debug']
    execute = args['--execute']
    random_seed = args['--random-seed']
 
    if debug:
        logging.basicConfig(level=logging.DEBUG)
 
    parsed = parse(sql_str)
    relations, conditions = get_relations_and_conditions(parsed)
    sample_size = parsed.sample_size if parsed.sample_size != '' else None
 
    query = Query(
        relations, 
        conditions=conditions, 
        columns=parsed.column_definitions,
        sample_size=sample_size,
        random_seed=random_seed,
        is_top_level=True
    )
    result = query.execute()
    result_str = result.get_cmd_str(output_column_names=True)
 
    if execute:
        # explicitly use bash instead of the default for subprocess(..., shell=True) which is sh
        result_str = "({})".format(result_str)
        proc = subprocess.Popen(['/bin/bash', '-c', result_str])

    else:
        result_str = result_str + "\n"
        print(result_str, end="")

    def __init__(self, dbconn, table):
        Query.__init__(self, dbconn)

        self._where = None
        self._target = None

        self.target(table)

    def flash(sqlsession, token, device):
        error = False
        errors = []
        token = None
        device = None

        if type(token) == int:
            token = sqlsession.query(models.Token).filter_by(id=token).first()
        if type(device) == int:
            device = sqlsession.query(models.Device).filter_by(id=device).first()

        if device:
            if token:
                try:
                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    s.connect((config.api_host, config.api_port))
                    temporary_token = helpers.generate_token()
                    q = Query()
                    q.create_register_webui(config.webui_token, temporary_token)
                    s.send(q.to_command())
                    q.create_flash(temporary_token, token.value, device.pubkey)
                    s.send(q.to_command())
                    q.create_unregister(temporary_token)
                    s.send(q.to_command())
                    s.close()
                except Exception:
                    error = True
                    errors.append(('flash', 'Connection to device failed.'))
            else:
                error = True
                errors.append(('token', 'Token does not exist.'))
        else:
                error = True
                errors.append(('device', 'Device does not exist.'))
        return error, errors

def _delete(self):
    Query.execute(
        'DELETE FROM %s WHERE id=%%s' % self.__table__ ,
        self.id,
        self.__db__
    )
    return True

 def test_english_highlighted_noop(self):
     phrases = [ Phrase('phrase type', { 'english' : 'foo' }, []),
                 Phrase('phrase type', { 'english' : 'bar' }, []),
                 Phrase('phrase type', { 'english' : 'baz' }, []) ]
     query = Query('the_table', phrases)
     query.set_base_atoms([Atom('atom type', 'ba')])
     self.assertEqual(query.get_english_highlighted(), 'Foo bar baz?')

 def requestAvatarId(self, cred): # pylint: disable=R0201
     """get user id from database"""
     args = cred.username.split(SERVERMARK)
     if len(args) > 1:
         if args[0] == 'adduser':
             cred.username = args[1]
             password = args[2]
             with Transaction():
                 query = Query('insert into player(name,password) values(?,?)',
                     list([cred.username.decode('utf-8'), password.decode('utf-8')]))
                 if not query.success:
                     if query.msg.startswith('ERROR: constraint failed') \
                     or 'not unique' in query.msg:
                         template = m18nE('User %1 already exists')
                         logInfo(m18n(template, cred.username))
                         query.msg = srvMessage(template, cred.username)
                     else:
                         logInfo(query.msg)
                     return fail(credError.UnauthorizedLogin(query.msg))
         elif args[1] == 'deluser':
             pass
     query = Query('select id, password from player where name=?',
         list([cred.username.decode('utf-8')]))
     if not len(query.records):
         template = 'Wrong username: %1'
         logInfo(m18n(template, cred.username))
         return fail(credError.UnauthorizedLogin(srvMessage(template, cred.username)))
     userid, password = query.records[0]
     # checkPassword uses md5 which cannot handle unicode strings (python 2.7)
     defer1 = maybeDeferred(cred.checkPassword, password.encode('utf-8'))
     defer1.addCallback(DBPasswordChecker._checkedPassword, userid)
     return defer1

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 []

def random_tweet():
    tweet = TwitterAPI.get_random_tweet()
    tweet_id = tweet['id']

    # Store the random tweet
    with open('tweets/%d.json' % tweet_id, 'w') as f:
        f.write(json.dumps(tweet))

    # Get our additional information
    query = Query(tweet['text'] + " " + tweet['user']['name'])
    query.run()
    article = query.get_result_article()
    article_file_name = query.get_result_filename()

    # Replace all the links in the article
    if article is not None:
        article = article.replace('/wiki/', 'https://en.wikipedia.org/wiki/')

    if article is not None:
        markup = TwitterAPI.get_tweet_markup(tweet_id)
        parameters = {
            'article_html': article,
            'article_filename': article_file_name,
            'tweet_html': markup,
            'ratings': [1, 2, 3, 4, 5],
            'tweet_id': tweet_id,
        }
        return render_template('tweet.html', **parameters)
    else:
        # We need to find another tweet
        return random_tweet()

def growth(playerId):
    sql = Query()
    queries = sql.quering_select("select Round(AVG(AVG1),3) from HitterGames where playerId="+str(playerId)+" Group by year,month")
    points = getPointArray(tupleToList(queries))
    queries = tupleToList(sql.quering_select("select year,month from HitterGames where playerId="+str(playerId)+" Group by year,month"))

    return {"date":queries, "points":points}

 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

  def select(*columns):
    cursor = Model.conn.cursor()
    query = Query(cursor)

    if columns:
      query.select(*columns)
    
    return query

 def reserveGameId(self, gameid):
     """the game server proposes a new game id. We check if it is available
     in our local data base - we want to use the same gameid everywhere"""
     with Internal.db:
         query = Query('insert into game(id,seed) values(?,?)',
                       (gameid, self.connection.url), mayFail=True, failSilent=True)
         if query.rowcount() != 1:
             return Message.NO
     return Message.OK

 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")