public List_adp Load(
      Xomp_mgr_db mgr_db, String machine_name, List_adp list, int list_idx, int list_len) {
    List_adp rv = List_adp_.New();

    // add remaining pages from old pool to new_pool;
    for (int i = list_idx; i < list_len; ++i) {
      rv.Add((Xomp_page_itm) list.Get_at(i));
    }

    // load pages into new pool
    Xomp_lock_mgr lock_mgr = mgr_db.Lock_mgr();
    int uid_db = lock_mgr.Uid_prv__get(machine_name);
    if (uid_db == Xomp_lock_mgr__fsys.Uid__eos)
      return rv; // assert that uids must be incrementally larger; handle one machine reaching end,
                 // and putting -1 in queue;
    int uid_new = 0;
    try {
      uid_new = this.Load_from_db(rv, uid_db);
    } finally {
      lock_mgr.Uid_prv__rls(machine_name, uid_new);
    }
    if (show_msg__fetched_pool)
      Gfo_usr_dlg_.Instance.Note_many(
          "", "", "fetched new pool: old=~{0} new=~{1}", uid_db, uid_new);
    return rv;
  }
示例#2
0
 public void Test_search(String search_word_str, int... expd) {
   Xowe_wiki wiki = bldr_fxt.Wiki();
   List_adp rv = List_adp_.new_();
   byte[] search_word_bry = Bry_.new_a7(search_word_str);
   wiki.Db_mgr_as_sql().Load_mgr().Load_search(Cancelable_.Never, rv, search_word_bry, 100);
   Tfds.Eq_ary(expd, Xto_int_ary(rv));
 }
示例#3
0
 public Xoud_site_row[] Select_all() {
   List_adp rv = List_adp_.new_();
   Db_rdr rdr = conn.Stmt_select(tbl_name, flds).Exec_select__rls_auto();
   try {
     while (rdr.Move_next()) rv.Add(new_row(rdr));
     return (Xoud_site_row[]) rv.To_ary_and_clear(Xoud_site_row.class);
   } finally {
     rdr.Rls();
   }
 }
示例#4
0
 int[] Xto_int_ary(Xoctg_data_ctg ctg) {
   List_adp list = List_adp_.new_();
   byte tid_max = Xoa_ctg_mgr.Tid__max;
   for (byte tid = 0; tid < tid_max; tid++) {
     Xoctg_idx_mgr grp = ctg.Grp_by_tid(tid);
     if (grp == null) continue;
     int len = grp.Itms_len();
     for (int i = 0; i < len; i++) {
       Xoctg_idx_itm itm = grp.Itms_get_at(i);
       list.Add(itm.Id());
     }
   }
   return (int[]) list.To_ary_and_clear(int.class);
 }
 @Override
 public void Cmd_run() {
   Init_bldr_bmks();
   this.time_bgn = System_.Ticks();
   int total_pending = Xob_xfer_regy_tbl.Select_total_pending(bldr_conn);
   // if (total_pending > 250000 && src_bin_mgr__fsdb_version == null)
   usr_dlg.Note_many("", "", "total pending: ~{0}", total_pending);
   List_adp list = List_adp_.New();
   boolean loop = true;
   while (loop) {
     byte rslt = Select_fsdb_itms(list);
     switch (rslt) {
       case Select_rv_stop:
         if (bin_db_mgr.Tier_id_is_last(tier_id_val)) loop = false;
         else {
           ++tier_id_val;
           page_id_val = 0;
           continue;
         }
         break;
       case Select_rv_next_page:
         ++page_id_val;
         lnki_id_val = 0;
         continue;
       case Select_rv_process:
         break;
     }
     if (!loop) break; // no more ttls found
     int len = list.Count();
     usr_dlg.Prog_many("", "", "fetched pages: ~{0}", len);
     for (int i = 0; i < len; ++i) {
       Xodb_tbl_oimg_xfer_itm fsdb = (Xodb_tbl_oimg_xfer_itm) list.Get_at(i);
       Download_itm(fsdb);
       if (exit_now
           || exec_count >= exec_count_max
           || exec_fail >= exec_fail_max
           || page_id_val >= page_id_end) {
         this.Txn_sav();
         return;
       }
     }
   }
   exec_done = true;
 }
 public Xobc_import_step_itm[] Select_by_task_id(int task_id) {
   List_adp list = List_adp_.New();
   Db_rdr rdr =
       conn.Stmt_sql(
               Db_sql_.Make_by_fmt(
                   String_.Ary(
                       "SELECT  s.*",
                       "FROM    import_step s",
                       "        JOIN step_map sm ON s.step_id = sm.step_id",
                       "WHERE   sm.task_id = {0}"),
                   task_id))
           .Exec_select__rls_auto();
   try {
     while (rdr.Move_next()) {
       list.Add(New_itm(rdr));
     }
   } finally {
     rdr.Rls();
   }
   return (Xobc_import_step_itm[]) list.To_ary_and_clear(Xobc_import_step_itm.class);
 }
示例#7
0
public class Mem_tbl {
  private final List_adp where_rows = List_adp_.New();
  private final Hash_adp autonum_hash = Hash_adp_.New();

  public Mem_tbl(Dbmeta_tbl_itm meta) {
    this.meta = meta;
  }

  public Dbmeta_tbl_itm Meta() {
    return meta;
  }

  private final Dbmeta_tbl_itm meta;
  public final List_adp rows = List_adp_.New();

  public int Insert(Mem_stmt stmt) {
    Mem_row itm = new Mem_row();
    Dbmeta_fld_mgr flds = meta.Flds();
    int len = flds.Len();
    for (int i = 0; i < len; ++i) {
      Dbmeta_fld_itm fld = flds.Get_at(i);
      String fld_name = fld.Name();
      Object val = fld.Autonum() ? Autonum_calc(fld_name) : stmt.Args_get_by(fld_name);
      if (val == null) continue; // NOTE: allow Bulk_insert from test to skip filds
      itm.Set_by(fld_name, val);
    }
    rows.Add(itm);
    return 1;
  }

  private int Autonum_calc(String name) {
    Int_obj_ref autonum_itm = (Int_obj_ref) autonum_hash.Get_by(name);
    if (autonum_itm == null) {
      autonum_itm = Int_obj_ref.New(0);
      autonum_hash.Add(name, autonum_itm);
    }
    return autonum_itm.Val_add();
  }

  public int Update(Mem_stmt stmt) {
    Db_qry_update qry = (Db_qry_update) stmt.Qry();
    Criteria where_crt = qry.Where();
    if (where_crt == null) where_crt = Criteria_.All;
    Mem_stmt_args_.Fill(stmt.Stmt_args(), where_crt);
    Select_rows_where(where_rows, stmt, where_crt);
    int where_rows_len = where_rows.Count();
    String[] update_cols = qry.Cols_for_update();
    int update_cols_len = update_cols.length;
    for (int i = 0; i < where_rows_len; ++i) {
      Mem_row itm = (Mem_row) where_rows.Get_at(i);
      for (int j = 0; j < update_cols_len; ++j) itm.Set_by(update_cols[j], stmt.Args_get_at(j));
    }
    return where_rows_len;
  }

  public int Delete(Mem_stmt stmt) {
    Db_qry_delete qry = (Db_qry_delete) stmt.Qry();
    Mem_stmt_args_.Fill(stmt.Stmt_args(), qry.Where());
    Select_rows_where(where_rows, stmt, qry.Where());
    int where_rows_len = where_rows.Count();
    for (int i = 0; i < where_rows_len; ++i) {
      Mem_row itm = (Mem_row) where_rows.Get_at(i);
      rows.Del(itm);
    }
    return where_rows_len;
  }

  public Db_rdr Select(Mem_stmt stmt) {
    String[] select = null;
    Criteria where = null;
    Db_qry__select_in_tbl qry = Db_qry__select_in_tbl.as_(stmt.Qry());
    if (qry == null) {
      Db_qry__select_cmd qry2 = (Db_qry__select_cmd) stmt.Qry();
      select = To_str_ary(qry2.Cols().Flds);
      where = qry2.Where_itm().Root;
    } else {
      select = qry.Select_flds();
      where = qry.Where();
    }
    Mem_stmt_args_.Fill(stmt.Stmt_args(), where);
    Select_rows_where(where_rows, stmt, where);
    return new Mem_rdr(select, (Mem_row[]) where_rows.To_ary_and_clear(Mem_row.class));
  }

  private String[] To_str_ary(Sql_select_fld_list flds) {
    int len = flds.Len();
    String[] rv = new String[len];
    for (int i = 0; i < len; ++i) rv[i] = flds.Get_at(i).Fld;
    return rv;
  }

  private void Select_rows_where(List_adp rv, Mem_stmt stmt, Criteria crt) {
    rv.Clear();
    int rows_len = rows.Count();
    for (int i = 0; i < rows_len; ++i) {
      Mem_row itm = (Mem_row) rows.Get_at(i);
      if (crt.Matches(itm)) rv.Add(itm);
    }
  }
}