Parameters:
     - login
     - tableName
353107
def listConstraints(self, login, tableName):
    
    self.send_listConstraints(login, tableName)
    return self.recv_listConstraints()
770780
def createTable(self, login, tableName, versioningIter, type):
    
    self.send_createTable(login, tableName, versioningIter, type)
    self.recv_createTable()
347044
def tablename(self) -> str:
        
        if self._tablename:
            return self._tablename
        return self.table.name
368151
def deleteRows(self, login, tableName, startRow, endRow):
    
    self.send_deleteRows(login, tableName, startRow, endRow)
    self.recv_deleteRows()
544494
def cli(conf):
    
    try:
        config = init_config(conf)
        debug = config.getboolean('DEFAULT', 'debug')
        conn = get_conn(config.get('DEFAULT','statusdb'))
        cur = conn.cursor()
        sqlstr = '''create table client_status
        (session_id text PRIMARY KEY, username text, userip text, 
            realip text, realport int,ctime int,
            inbytes int, outbytes int, 
            acct_interval int, session_timeout int, uptime int)
        '''
        try:
            cur.execute('drop table client_status')
        except:
            pass
        cur.execute(sqlstr)
        print 'flush client status database'
        conn.commit()
        conn.close()
    except:
        traceback.print_exc()
559511
def loggin(self, user_id, mdp, autolog):
        """"""
        r = sql.abstractRequetesSQL.check_mdp_user(user_id, mdp)
        if r():
            # update auto-log params
            self.autolog[user_id] = autolog and mdp or False
            self.modules = self.users[user_id]["modules"]  # load modules list

            dic = {"autolog": self.autolog, "modules": self.modules}
            s = json.dumps(dic, indent=4, ensure_ascii=False)
            b = security.protege_data(s, True)
            with open("local/init", "wb") as f:
                f.write(b)

            self.mode_online = True  # authorization to execute bakground tasks
            return True
        else:
            logging.debug("Bad password !")
338777
def importDirectory(self, login, tableName, importDir, failureDir, setTime):
    
    self.send_importDirectory(login, tableName, importDir, failureDir, setTime)
    self.recv_importDirectory()
1354275
def flushTable(self, login, tableName, startRow, endRow, wait):
    
    self.send_flushTable(login, tableName, startRow, endRow, wait)
    self.recv_flushTable()
599098
def updateAndFlush(self, login, tableName, cells):
    
    self.send_updateAndFlush(login, tableName, cells)
    self.recv_updateAndFlush()
417096
def _login(self, username="", password=""):
        
        self.log.debug("----------------")
        self.log.debug("Logging in (username: %s)..." % username)

        def run_query():
            return self._xmlrpc_server.LogIn(
                username, password, self.language, self.user_agent)

        info = self._safe_exec(run_query, None)
        if info is None:
            self._token = None
            return False

        self.log.debug("Login ended in %s with status: %s" %
                       (info['seconds'], info['status']))

        if info['status'] == "200 OK":
            self.log.debug("Session ID: %s" % info['token'])
            self.log.debug("----------------")
            self._token = info['token']
            return True
        else:
            # force token reset
            self.log.debug("----------------")
            self._token = None
            return False
154726
public void login(String username, String passwd, String domain) {
    this.login = getPerformedAction(new PostLogin(username, passwd, domain)).getLoginData();
    loginChangeUserInfo = true;
    if (getVersion() == Version.UNKNOWN) {
      loginChangeVersion = true;
    }
  }
1164202
def login(self, **kwargs):
        
        assert self.LOGIN_URL_PATH is not None

        render_name = kwargs.pop("render", "json")
        render = get_renderer(render_name)
        params = parse_args(**kwargs)
        return self.post(self.LOGIN_URL_PATH, body_params=params, render=render)
380952
def login(self, username, password):
        ""
        log.debug("Logging in to the DB")
        opener = self._build_opener()
        values = {'usr': username, 'pwd': password}
        req = self._make_request(self._login_url, values)
        try:
            log.debug("Sending login request")
            f = opener.open(req)
        except URLError as e:
            log.error("Failed to connect to the database -> probably down!")
            log.error("Error from database server:\n    {0}".format(e))
            return False
        html = f.read()
        failed_auth_message = 'Bad username or password'
        if failed_auth_message in str(html):
            log.error(failed_auth_message)
            return False
        return True
747134
def get_table_info(conn, tablename):
    """"""
    r = conn.execute("pragma table_info('{}')".format(tablename))
    ret = TableInfo(((row["name"], row) for row in r))
    return ret
693142
def _create_table(self, table_name):
        ''' 
        '''
        if self.fieldnames:
            sql_fields = []
            for field in self._fields:
                if field != '_id':
                    if 'dblite' in self._fields[field]:
                        sql_fields.append(' '.join([field, self._fields[field]['dblite']]))
                    else:
                        sql_fields.append(field)
            sql_fields = ','.join(sql_fields)
            SQL = 'CREATE TABLE IF NOT EXISTS %s (%s);' % (table_name, sql_fields)
            try:
                self._cursor.execute(SQL)
            except sqlite3.OperationalError, err:
                raise RuntimeError('Create table error, %s, SQL: %s' % (err, SQL))
95565
def addConstraint(self, login, tableName, constraintClassName):
    
    self.send_addConstraint(login, tableName, constraintClassName)
    return self.recv_addConstraint()
1081695
def get_param_name(self):
        
        return "__".join([self.table.name, self.name, self.param_name])