Exemple #1
0
 public Xowv_wiki(Xoav_app app, byte[] domain_bry, Io_url wiki_root_dir) {
   this.app = app;
   this.domain_bry = domain_bry;
   this.domain_str = String_.new_u8(domain_bry);
   this.domain_itm = Xow_domain_itm_.parse(domain_bry);
   this.domain_tid = domain_itm.Domain_type_id();
   this.domain_abrv = Xow_abrv_wm_.To_abrv(Xow_domain_itm_.parse(domain_bry));
   this.ns_mgr = Xow_ns_mgr_.default_(app.Utl_case_mgr());
   this.lang =
       app.Lang_mgr()
           .Get_by_or_en(
               domain_itm
                   .Lang_actl_key()); // NOTE: must not be null, or causes null ref exception on
                                      // redlinks in drd; DATE:2016-06-28
   this.msg_mgr = new Xow_msg_mgr(this, lang);
   this.html__hdump_mgr = new Xow_hdump_mgr(this);
   this.special_mgr = new Xosp_special_mgr(this);
   this.fsys_mgr =
       new Xow_fsys_mgr(wiki_root_dir, app.Fsys_mgr().File_dir().GenSubDir(domain_str));
   this.fsdb_mgr = new Xof_fsdb_mgr__sql();
   this.url__parser = new Xow_url_parser(this);
   this.xwiki_mgr = new Xow_xwiki_mgr(this);
   this.stats = new Xow_site_stats_mgr(this);
   this.lnki_bldr = new Xoh_lnki_bldr(app, href_wtr);
   this.ctg_catpage_mgr = new Xoctg_catpage_mgr(this);
 }
 public static Xob_db_file New__deletion_db(Xow_wiki wiki) {
   String name =
       String_.Format(
           "{0}-file-deletion-{1}.xowa",
           wiki.Domain_str(), Datetime_now.Get().XtoStr_fmt("yyyy.MM"));
   return New(wiki.Fsys_mgr().Root_dir(), name);
 }
public class Xob_xfer_regy_log_tbl {
  public static void Create_table(Db_conn p) {
    gplx.dbs.engines.sqlite.Sqlite_engine_.Tbl_create_and_delete(p, Tbl_name, Tbl_sql);
  }

  public static Db_stmt Insert_stmt(Db_conn p) {
    return Db_stmt_.new_insert_(
        p, Tbl_name, Fld_lnki_id, Fld_xfer_status, Fld_xfer_bin_tid, Fld_xfer_bin_msg);
  }

  public static void Insert(Db_stmt stmt, byte status, int id, byte wkr_tid, String wkr_msg) {
    stmt.Clear().Val_int(id).Val_byte(status).Val_byte(wkr_tid).Val_str(wkr_msg).Exec_insert();
  }

  private static final String Tbl_sql =
      String_.Concat_lines_nl(
          "CREATE TABLE IF NOT EXISTS xfer_regy_log",
          "( lnki_id             integer             NOT NULL",
          ", xfer_status         tinyint             NOT NULL" // 0=todo; 1=fail; 2=pass; 3=done
          ,
          ", xfer_bin_tid        tinyint             NOT NULL",
          ", xfer_bin_msg        varchar(255)        NOT NULL",
          ");");
  public static final String Tbl_name = "xfer_regy_log",
      Fld_lnki_id = "lnki_id",
      Fld_xfer_status = "xfer_status",
      Fld_xfer_bin_tid = "xfer_bin_tid",
      Fld_xfer_bin_msg = "xfer_bin_msg";
}
Exemple #4
0
 public void Init_by_wiki() {
   if (!init_needed) return;
   init_needed = false;
   if (String_.Eq(domain_str, "xowa"))
     return; // HACK: ignore "xowa" for now; WHEN:converting xowa to sqlitedb
   data_mgr__core_mgr = new Xow_db_mgr(this, fsys_mgr.Root_dir());
   data_mgr__core_mgr.Init_by_load(gplx.xowa.wikis.data.Xow_db_file__core_.Find_core_fil(this));
   app.Html__css_installer()
       .Install(this, Xowd_css_core_mgr.Key_mobile); // must init after data_mgr
   this.db_core_mgr = Fsdb_db_mgr_.new_detect(this, fsys_mgr.Root_dir(), fsys_mgr.File_dir());
   if (db_core_mgr
       == null) // no fsdb; occurs during merge; also, will be null for xowa_db; DATE:2016-05-31
   db_core_mgr = Fsdb_db_mgr__v2_bldr.Get_or_make(this, true);
   else // fsdb exists; load it
   fsdb_mgr.Mnt_mgr().Ctor_by_load(db_core_mgr);
   file_mgr__repo_mgr.Add_repo(
       app, fsys_mgr.File_dir(), Xow_domain_itm_.Bry__commons, Xow_domain_itm_.Bry__commons);
   file_mgr__repo_mgr.Add_repo(app, fsys_mgr.File_dir(), domain_bry, domain_bry);
   Xof_orig_tbl[] orig_tbls =
       db_core_mgr == null ? new Xof_orig_tbl[0] : db_core_mgr.File__orig_tbl_ary();
   orig_mgr.Init_by_wiki(this, file_mgr__fsdb_mode, orig_tbls, Xof_url_bldr.new_v2());
   fsdb_mgr.Init_by_wiki(this);
   data_mgr__core_mgr.Db__core().Tbl__ns().Select_all(ns_mgr);
   data_mgr__core_mgr.Db__core().Tbl__site_stats().Select(stats);
   html__hdump_mgr.Init_by_db(this);
   app.Addon_mgr().Load_by_wiki(this);
   ctg_pagebox_wtr.Init_by_wiki(this);
 }
 public void Select_tasks_steps(
     Xobc_task_step_hash task_step_hash,
     Xobc_step_map_tbl step_map_tbl,
     byte[] wiki_abrv,
     String wiki_date) {
   task_step_hash.Clear();
   Db_rdr rdr =
       conn.Stmt_sql(
               String_.Concat_lines_nl_skip_last(
                   "SELECT  DISTINCT sm.task_id, sm.step_id",
                   "FROM    " + tbl_name + " imps",
                   "        JOIN " + step_map_tbl.Tbl_name() + " sm ON sm.step_id = imps.step_id",
                   "WHERE   imps.wiki_abrv = ?",
                   "AND     imps.wiki_date = ?"))
           .Crt_bry_as_str(fld_wiki_abrv, wiki_abrv)
           .Crt_str(fld_wiki_date, wiki_date)
           .Exec_select__rls_auto();
   try {
     while (rdr.Move_next()) {
       task_step_hash.Add(rdr.Read_int("task_id"), rdr.Read_int("step_id"));
     }
   } finally {
     rdr.Rls();
   }
 }
  private int Load_from_db(List_adp list, int uid_prv) {
    // prepare for page_tbl
    String sql =
        String_.Format(
            String_.Concat_lines_nl_skip_last // ANSI.Y
                (
                "SELECT  mp.xomp_uid",
                ",       pp.page_id",
                ",       pp.page_namespace",
                ",       pp.page_title",
                ",       pp.page_text_db_id",
                "FROM    xomp_page mp",
                "        JOIN <page_db>page pp ON mp.page_id = pp.page_id",
                "WHERE   mp.xomp_uid > {0}",
                "AND     mp.page_status = 0",
                "LIMIT   {1}"),
            uid_prv,
            num_pages_per_load);
    this.attach_mgr.Conn_links_(
        new Db_attach_itm("page_db", wiki.Data__core_mgr().Db__core().Conn()));
    sql = attach_mgr.Resolve_sql(sql);

    // run page_tbl
    int rv = -1;
    Xomp_text_db_loader text_db_loader = new Xomp_text_db_loader(wiki);
    attach_mgr.Attach();
    Db_rdr rdr = make_conn.Stmt_sql(sql).Exec_select__rls_auto();
    try {
      while (rdr.Move_next()) {
        rv = rdr.Read_int("xomp_uid");
        int text_db_id = rdr.Read_int("page_text_db_id");
        Xomp_page_itm ppg = new Xomp_page_itm(rdr.Read_int("page_id"));
        ppg.Init_by_page(
            rdr.Read_int("page_namespace"), rdr.Read_bry_by_str("page_title"), text_db_id);
        list.Add(ppg);
        text_db_loader.Add(text_db_id, ppg);
      }
    } finally {
      rdr.Rls();
    }
    attach_mgr.Detach();

    text_db_loader.Load();
    return rv;
  }
 public static Fsdb_db_mgr new_src_bin_db_mgr(Xow_wiki wiki, String version) {
   String domain_str = wiki.Domain_str();
   Fsdb_db_mgr rv = null;
   Io_url url = null;
   if (String_.Eq(version, "v1")) {
     url =
         wiki.Fsys_mgr()
             .File_dir()
             .OwnerDir()
             .GenSubDir(domain_str + "-prv"); // v1: EX: /xowa/file/en.wikipedia.org-prv/
     rv = new Fsdb_db_mgr__v1(url);
   } else if (String_.Eq(version, "v2")) {
     url = wiki.Fsys_mgr().Root_dir().GenSubDir("prv"); // v2: EX: /xowa/wiki/en.wikipedia.org/prv/
     rv = Fsdb_db_mgr_.new_detect(wiki, url, url); // note that v2 is prioritized over v1
   } else throw Err_.new_wo_type("fsdb.make:unknown fsdb_type", "version", version);
   if (rv == null)
     throw Err_.new_wo_type(
         "fsdb.make:source fsdb not found", "version", version, "url", url.Raw());
   return rv;
 }
 private void Download_exec(Xodb_tbl_oimg_xfer_itm fsdb) {
   Io_stream_rdr src_rdr = src_bin_mgr.Find_as_rdr(Xof_exec_tid.Tid_wiki_page, fsdb);
   try {
     if (src_rdr == Io_stream_rdr_.Noop) { // download failed
       ++exec_fail;
       usr_dlg.Warn_many(
           "",
           "",
           "failed: ttl=~{0}",
           String_.Format("[[File:{0}|{1}px]]", fsdb.Orig_ttl(), fsdb.Html_w()));
       Print_progress(fsdb);
     } else { // download passed
       long src_rdr_len = src_rdr.Len();
       int lnki_tier_id = fsdb.Lnki_tier_id();
       if (src_rdr_len > download_size_max && !Int_.In(lnki_tier_id, download_keep_tier_ids)) {
         usr_dlg.Warn_many(
             "",
             "",
             "skipped; ttl=~{0} w=~{1} size=~{2} tier=~{3}",
             fsdb.Orig_ttl(),
             fsdb.Lnki_w(),
             src_rdr_len,
             lnki_tier_id);
         return;
       }
       if (trg_bin_fil == null) // no trg_bin_fil
       Make_trg_bin_file(Bool_.Y, fsdb, src_rdr_len);
       else if (trg_bin_fil.Bin_len() + src_rdr_len
           > trg_bin_db_max) // or trg_bin_fil is out of space
       Make_trg_bin_file(Bool_.N, fsdb, src_rdr_len);
       else if (prv_lnki_tier_id != lnki_tier_id) { // or tier has changed
         if (prv_lnki_tier_id != -1 && !bin_db_mgr.Schema_is_1()) // do not increment dbs for v1
         Make_trg_bin_file(Bool_.Y, fsdb, src_rdr_len);
         prv_lnki_tier_id = lnki_tier_id;
       }
       trg_bin_updater.Save_bin(trg_mnt_itm, trg_atr_fil, trg_bin_fil, fsdb, src_rdr, src_rdr_len);
     }
   } finally {
     src_rdr.Rls();
   }
 }
 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);
 }
Exemple #10
0
 public int Autonum_next(String tbl, String fld) {
   return Autonum_next(String_.Concat(tbl, ".", fld));
 }
 @Override
 public void Cmd_run() {
   wiki.Init_by_wiki();
   Xow_db_file core_db = wiki.Data__core_mgr().Db__core();
   Db_conn core_db_conn = core_db.Conn();
   Gfo_usr_dlg usr_dlg = Gfo_usr_dlg_.Instance;
   usr_dlg.Plog_many("", "", "creating page_filter");
   if (!core_db_conn.Meta_tbl_exists("page_filter")) {
     core_db_conn.Meta_tbl_create(
         Dbmeta_tbl_itm.New(
             "page_filter",
             new Dbmeta_fld_itm[] {
               Dbmeta_fld_itm.new_int("page_id").Primary_y_(),
               Dbmeta_fld_itm.new_int("page_text_db_id")
             },
             Dbmeta_idx_itm.new_normal_by_tbl(
                 "page_filter", "db_id__page", "page_text_db_id", "page_id"),
             Dbmeta_idx_itm.new_normal_by_tbl("page_filter", "page_id", "page_id")));
   }
   core_db_conn.Exec_sql_plog_ntx(
       "finding missing redirects",
       String_.Concat_lines_nl_skip_last(
           "INSERT INTO page_filter (page_id, page_text_db_id)",
           "SELECT  ptr.page_id, ptr.page_text_db_id",
           "FROM    page ptr",
           "        LEFT JOIN page orig ON ptr.page_redirect_id = orig.page_id",
           "WHERE   ptr.page_is_redirect = 1",
           "AND     orig.page_id IS NULL",
           "UNION",
           "SELECT  ptr.page_id, ptr.page_text_db_id",
           "FROM    page ptr",
           "WHERE   ptr.page_is_redirect = 1",
           "AND     ptr.page_redirect_id = -1",
           ";"));
   try {
     Xow_db_file[] db_file_ary =
         core_db.Tbl__db().Select_all(wiki.Data__core_mgr().Props(), wiki.Fsys_mgr().Root_dir());
     int len = db_file_ary.length;
     for (int i = 0; i < len; ++i) {
       boolean db_file_is_text = Bool_.N, db_file_is_cat = Bool_.N, db_file_is_search = Bool_.N;
       Xow_db_file db_file = db_file_ary[i];
       switch (db_file.Tid()) {
         case Xow_db_file_.Tid__core:
         case Xow_db_file_.Tid__wiki_solo:
         case Xow_db_file_.Tid__text_solo:
           if (wiki.Data__core_mgr().Props().Layout_text().Tid_is_lot())
             continue; // if mode is lot, then "core" db does not have text, cat, search; skip;
           // DATE:2016-01-31
           db_file_is_text = db_file_is_cat = db_file_is_search = Bool_.Y;
           break;
         case Xow_db_file_.Tid__text:
           db_file_is_text = Bool_.Y;
           break;
         case Xow_db_file_.Tid__cat:
           db_file_is_cat = Bool_.Y;
           break;
         case Xow_db_file_.Tid__search_core:
           db_file_is_search = Bool_.Y;
           break;
       }
       int db_id = db_file.Id();
       if (db_file_is_text)
         Run_sql(
             core_db_conn,
             db_file.Url(),
             db_id,
             "deleting text: " + db_id,
             "DELETE FROM <data_db>text WHERE page_id IN (SELECT page_id FROM page_filter WHERE page_text_db_id = {0});");
       if (db_file_is_cat)
         Run_sql(
             core_db_conn,
             db_file.Url(),
             db_id,
             "deleting cat: " + db_id,
             "DELETE FROM <data_db>cat_link WHERE cl_from IN (SELECT page_id FROM page_filter);");
       if (db_file_is_search)
         Run_sql(
             core_db_conn,
             db_file.Url(),
             db_id,
             "deleting search:" + db_id,
             "DELETE FROM <data_db>search_link WHERE page_id IN (SELECT page_id FROM page_filter);");
       if (db_file_is_text || db_file_is_cat || db_file_is_search) db_file.Conn().Env_vacuum();
     }
   } catch (Exception e) {
     Gfo_usr_dlg_.Instance.Warn_many(
         "", "", "fatal error during page deletion: err=~{0}", Err_.Message_gplx_log(e));
   }
   core_db_conn.Exec_sql_plog_ntx(
       "deleting from table: page",
       "DELETE FROM page WHERE page_id IN (SELECT page_id FROM page_filter);");
   // core_db_conn.Meta_tbl_delete("page_filter");
   core_db_conn.Env_vacuum();
   usr_dlg.Plog_many("", "", "");
 }
public class Xob_xfer_temp_cmd_thumb extends Xob_itm_basic_base implements Xob_cmd {
  public Xob_xfer_temp_cmd_thumb(Xob_bldr bldr, Xowe_wiki wiki) {
    this.Cmd_ctor(bldr, wiki);
  }

  public String Cmd_key() {
    return Xob_cmd_keys.Key_file_xfer_temp_thumb;
  }

  public void Cmd_init(Xob_bldr bldr) {}

  public void Cmd_bgn(Xob_bldr bldr) {
    Db_conn conn = Xob_db_file.new__file_make(wiki.Fsys_mgr().Root_dir()).Conn();
    Xob_xfer_temp_tbl.Create_table(conn);
    Db_stmt trg_stmt = Xob_xfer_temp_tbl.Insert_stmt(conn);
    conn.Txn_bgn();
    DataRdr rdr = conn.Exec_sql_as_rdr(Sql_select);
    Xob_xfer_temp_itm temp_itm = new Xob_xfer_temp_itm();
    Xof_img_size img_size = new Xof_img_size();
    byte[] cur_ttl = Bry_.Empty;
    byte cur_repo = Byte_.Max_value_127;
    while (rdr.MoveNextPeer()) {
      temp_itm.Clear();
      temp_itm.Load(rdr);
      if (Bry_.Eq(cur_ttl, temp_itm.Orig_file_ttl())) { // same ttl; DATE:2015-03-22
        if (temp_itm.Orig_repo()
            != cur_repo) // if repo is different, ignore 2nd; handles images in both repos; take 1st
          // only (which should be local)
          continue;
      } else { // new ttl; update ttl, repo
        cur_ttl = temp_itm.Orig_file_ttl();
        cur_repo = temp_itm.Orig_repo();
      }
      if (temp_itm.Chk(img_size)) temp_itm.Insert(trg_stmt, img_size);
    }
    conn.Txn_end();
  }

  public void Cmd_run() {}

  public void Cmd_end() {}

  public void Cmd_term() {}

  private static final String Sql_select =
      String_.Concat_lines_nl(
          "SELECT  l.lnki_id",
          ",       l.lnki_tier_id",
          ",       l.lnki_page_id",
          ",       l.lnki_ext",
          ",       l.lnki_type",
          ",       l.lnki_src_tid",
          ",       l.lnki_w",
          ",       l.lnki_h",
          ",       l.lnki_upright",
          ",       l.lnki_time",
          ",       l.lnki_page",
          ",       l.lnki_count",
          ",       o.orig_repo",
          ",       o.orig_page_id",
          ",       o.orig_file_ttl",
          ",       o.orig_file_ext",
          ",       o.orig_file_id",
          ",       o.lnki_ttl",
          ",       o.orig_w",
          ",       o.orig_h",
          ",       o.orig_media_type",
          ",       o.orig_minor_mime",
          "FROM    lnki_regy l",
          "        JOIN orig_regy o ON o.lnki_ttl = l.lnki_ttl",
          "WHERE   o.orig_file_ttl IS NOT NULL",
          "ORDER BY o.orig_file_ttl, o.orig_repo DESC, l.lnki_w DESC" // NOTE: local=1,common=0;
          // DATE:2015-03-22
          );
}
 @Override
 public void Cmd_bgn(Xob_bldr bldr) {
   wiki.Init_assert();
   this.poll_interval = poll_mgr.Poll_interval();
   this.bin_db_mgr = new Xob_bin_db_mgr(ns_ids);
   // src_bin_mgr
   if (src_bin_mgr__fsdb_version != null) {
     this.src_fsdb_wkr = Xof_bin_wkr__fsdb_sql.new_(wiki.File__mnt_mgr());
     src_bin_mgr.Wkrs__add(src_fsdb_wkr);
     src_fsdb_wkr.Mnt_mgr().Ctor_by_load(new_src_bin_db_mgr(wiki, src_bin_mgr__fsdb_version));
     src_fsdb_wkr.Mnt_mgr()
         .Mnts__get_main()
         .Txn_bgn(); // NOTE: txn on atr speeds up from 50 -> 300; DATE:2015-03-21
     if (src_bin_mgr__fsdb_skip_wkrs != null) {
       src_fsdb_wkr.Skip_mgr_init(
           src_fsdb_wkr.Mnt_mgr().Mnts__get_main().Cfg_mgr(), src_bin_mgr__fsdb_skip_wkrs);
     }
     if (src_bin_mgr__cache_enabled) {
       usr_dlg.Prog_many("", "", "src_bin_mgr.cache.bgn");
       src_fsdb_wkr.Mnt_mgr().Mnts__get_main().Atr_mgr().Db__core().Fil_cache_enabled_y_();
       usr_dlg.Prog_many("", "", "src_bin_mgr.cache.end");
     }
   }
   if (src_bin_mgr__wmf_enabled) {
     Xof_bin_wkr__http_wmf wmf_wkr = Xof_bin_wkr__http_wmf.new_(wiki);
     src_bin_mgr.Wkrs__add(wmf_wkr);
     wmf_wkr.Fail_timeout_(
         0); // 1000; NOTE: set Fail_timeout here; DATE:2014-06-21; NOTE: do not put in ctor, or
     // else will be 1st wkr; DATE:2014-06-28
   }
   // trg_mnt_itm
   this.trg_bin_db_max = app.Api_root().Bldr().Wiki().Import().File_db_max();
   Io_url trg_file_dir_v1 =
       String_.Eq(trg_bin_mgr__fsdb_version, "v1")
           ? wiki.Fsys_mgr().File_dir().GenNewNameOnly(wiki.Domain_str() + "-prv")
           : wiki.Fsys_mgr().File_dir(); // NOTE: convoluted way of setting trg to -prv if
   // trg_bin_mgr__fsdb_version_v1 is set; otherwise set to
   // "en.wikipedia.org" which will noop; DATE:2015-12-02
   Fsdb_db_mgr trg_db_mgr =
       Fsdb_db_mgr_.new_detect(wiki, wiki.Fsys_mgr().Root_dir(), trg_file_dir_v1);
   if (trg_db_mgr == null) trg_db_mgr = Fsdb_db_mgr__v2_bldr.Get_or_make(wiki, Bool_.Y);
   Fsm_mnt_mgr trg_mnt_mgr = new Fsm_mnt_mgr();
   trg_mnt_mgr.Ctor_by_load(trg_db_mgr);
   trg_mnt_mgr.Mnts__get_insert_idx_(
       Fsm_mnt_mgr
           .Mnt_idx_main); // NOTE: do not delete; mnt_mgr default to Mnt_idx_user; DATE:2014-04-25
   this.trg_mnt_itm = trg_mnt_mgr.Mnts__get_insert();
   Fsm_mnt_mgr.Patch(
       trg_mnt_itm.Cfg_mgr()
           .Tbl()); // NOTE: always patch again; fsdb_make may be run separately without lnki_temp;
   // DATE:2014-04-26
   this.trg_atr_fil = trg_mnt_itm.Atr_mgr().Db__core();
   this.trg_cfg_mgr = trg_mnt_itm.Cfg_mgr();
   bin_db_mgr.Init_by_mnt_mgr(trg_mnt_mgr);
   trg_atr_fil.Conn().Txn_bgn("bldr__fsdb_make__trg_atr_fil");
   if (!trg_atr_fil.Conn()
       .Eq(trg_cfg_mgr.Tbl().Conn())) // need to create txn for v1; DATE:2015-07-04
   trg_cfg_mgr.Tbl().Conn().Txn_bgn("bldr__fsdb_make__trg_cfg_fil");
   // bldr_db
   Xob_db_file bldr_db = Xob_db_file.New__file_make(wiki.Fsys_mgr().Root_dir());
   this.bldr_conn = bldr_db.Conn();
   this.bldr_cfg_tbl = bldr_db.Tbl__cfg(); // NOTE: cfg and atr is in same db; use it
   bldr_cfg_tbl.Conn().Txn_bgn("bldr__fsdb_make__bldr_cfg_tbl");
 }
 private void Init(Db_engine engine) {
   init = false;
   tbl_mgr.Clear();
   idx_mgr.Clear();
   Dbmeta_parser__tbl tbl_parser = new Dbmeta_parser__tbl();
   Dbmeta_parser__idx idx_parser = new Dbmeta_parser__idx();
   Db_qry__select_in_tbl qry =
       Db_qry__select_in_tbl.new_(
           "sqlite_master",
           String_.Ary_empty,
           String_.Ary("type", "name", "sql"),
           Db_qry__select_in_tbl.Order_by_null);
   Db_rdr rdr = engine.Stmt_by_qry(qry).Exec_select__rls_auto();
   try {
     Gfo_usr_dlg_.Instance.Log_many(
         "", "", "db.schema.load.bgn: conn=~{0}", engine.Conn_info().Db_api());
     while (rdr.Move_next()) {
       String type_str = rdr.Read_str("type");
       String name = rdr.Read_str("name");
       String sql = rdr.Read_str("sql");
       try {
         int type_int = Dbmeta_itm_tid.Xto_int(type_str);
         switch (type_int) {
           case Dbmeta_itm_tid.Tid_table:
             if (String_.Has_at_bgn(name, "sqlite_"))
               continue; // ignore b/c of non-orthodox syntax; EX: "CREATE TABLE
                         // sqlite_sequence(name, seq)"; also "CREATE TABLE
                         // sqlite_stat(tbl,idx,stat)";
             tbl_mgr.Add(tbl_parser.Parse(Bry_.new_u8(sql)));
             break;
           case Dbmeta_itm_tid.Tid_index:
             if (sql == null)
               continue; // ignore "autoindex"; EX: sqlite_autoindex_temp_page_len_avg_1
             idx_mgr.Add(idx_parser.Parse(Bry_.new_u8(sql)));
             break;
           default:
             Gfo_usr_dlg_.Instance.Log_many(
                 "",
                 "",
                 "db.schema.unknown type: conn=~{0} type=~{1} name=~{2} sql=~{3}",
                 engine.Conn_info().Db_api(),
                 type_str,
                 name,
                 sql);
             break;
         }
       } catch (
           Exception
               e) { // tables / indexes may be unparseable; skip them; EX: CREATE TABLE unparseable
                    // (col_1 /*comment*/ int); DATE:2016-06-08
         Gfo_usr_dlg_.Instance.Log_many(
             "",
             "",
             "db.schema.unparseable: conn=~{0} type=~{1} name=~{2} sql=~{3} err=~{4}",
             engine.Conn_info().Db_api(),
             type_str,
             name,
             sql,
             Err_.Message_gplx_log(e));
       }
     }
   } finally {
     rdr.Rls();
   }
 }
Exemple #15
0
 public void Test_load_page(int ns_id, int page_id, String expd) {
   Xowe_wiki wiki = bldr_fxt.Wiki();
   Xow_ns ns = wiki.Ns_mgr().Ids_get_or_null(ns_id);
   wiki.Db_mgr_as_sql().Load_mgr().Load_page(actl.Id_(page_id), ns, false);
   Tfds.Eq(expd, String_.new_a7(actl.Text()));
 }