protected Repository(
IDatabaseReader <TEntity> databaseReader,
IDatabaseWriter <TEntity> databaseWriter)
{
DatabaseReader = databaseReader;
DatabaseWriter = databaseWriter;
}
private void wpTarget_CloseFromNext(object sender, Gui.Wizard.PageEventArgs e)
{
if (addonSelectFrame1.SelectedObject is IDatabaseWriter)
{
m_target = (IDatabaseWriter)addonSelectFrame1.SelectedObject;
}
else if (addonSelectFrame1.SelectedObject is DatabaseWriterChooser)
{
m_target = m_writerChooser.GetDatabaseWriter();
}
if (m_target != null)
{
try
{
m_target.CheckConfiguration(m_source);
}
catch (Exception err)
{
Errors.Report(err);
e.Page = wpTarget;
return;
}
}
else
{
StdDialog.ShowError("s_please_select_database");
e.Page = wpTarget;
}
}
public override void LoadFromXml(XmlElement xml)
{
base.LoadFromXml(xml);
m_src = (IDatabaseSource)DatabaseSourceAddonType.Instance.LoadAddon(xml.FindElement("Source"));
m_dst = (IDatabaseWriter)DatabaseWriterAddonType.Instance.LoadAddon(xml.FindElement("Target"));
m_copyOpts = new DatabaseCopyOptions();
m_copyOpts.LoadFromXml(xml.FindElement("Options"));
}
public DataWriteFactory(IFileReader reader, IParser parser, IDatabaseWriter writer)
{
_fileReader = reader;
_parser = parser;
_writer = writer;
_taskFactory = new TaskFactory(TaskCreationOptions.LongRunning,
TaskContinuationOptions.None);
}
public void Start()
{
m_databaseFileWriter = m_writerFactory(FileName);
m_databaseFileReader = m_readerFactory(FileName);
m_cacheProvider = m_cacheProviderFactory(FileName);
ulong timestamp;
m_documentStore = new DocumentStore(m_databaseFileReader.GetDocuments(out timestamp));
DBTimeStamp = timestamp;
}
public DatafordelereDatabaseWriter(
ILogger <DatafordelereDatabaseWriter> logger,
IOptions <KafkaSetting> kafkaSetting,
IOptions <DatabaseSetting> databaseSetting,
IDatabaseWriter databaseWriter,
IPostgresWriter postgresWriter
)
{
_logger = logger;
_kafkaSetting = kafkaSetting.Value;
_databaseSetting = databaseSetting.Value;
_databaseWriter = databaseWriter;
_postgresWriter = postgresWriter;
}
public void Stop()
{
m_databaseFileWriter.Dispose();
m_databaseFileWriter = null;
m_databaseFileReader.Dispose();
m_databaseFileReader = null;
m_documentStore = null;
m_pendingTransaction.Clear();
m_pendingTransaction = null;
m_currentTransactionId = 0;
DBTimeStamp = 0;
}
public UnifiToSqlDatabaseExporter(
IBlacklist blacklist,
ICheckerCommandCreatorProvider checkerCommandCreatorProvider,
IWriterCommandCreatorProvider writerCommandCreatorProvider,
IDatabaseChecker checker,
IDatabaseWriter writer,
ICustomLogger customLogger,
int batchSize)
{
_checkerCommandCreatorProvider = checkerCommandCreatorProvider;
_writerCommandCreatorProvider = writerCommandCreatorProvider;
_checker = checker;
_writer = writer;
_customLogger = customLogger;
_batchSize = batchSize;
_blacklist = blacklist;
}
protected override void DoRun(IJobRunEnv env)
{
string dir = GetBackupDir();
try { Directory.CreateDirectory(dir); }
catch { }
string bckfile = Path.Combine(dir, CreateFileName());
IDatabaseWriter writer = m_format.GetWriter(bckfile + m_format.Extension, m_src);
var copyOpts = new DatabaseCopyOptions
{
CopyMembers = m_members,
DataMode = DbCopyDataMode.All,
CopyStructure = true,
SchemaMode = m_src.Dialect.DialectCaps.MultipleSchema ? DbCopySchemaMode.Original : DbCopySchemaMode.Explicit,
ExplicitSchema = null
};
CopyDbJob.CopyDatabase(m_src, writer, ProgressInfo, copyOpts);
SetCurWork(Texts.Get("s_finishing"));
BackupContainer bc = new BackupContainer(bckfile, m_format);
bc.Save();
}
public TranslationRepository(IDatabaseReader <TranslationEntity> databaseReader, IDatabaseWriter <TranslationEntity> databaseWriter) : base(databaseReader, databaseWriter)
{
}
public CopyDbJobCommand(IDatabaseSource src, IDatabaseWriter dst, DatabaseCopyOptions copyOpts)
{
m_src = src;
m_dst = dst;
m_copyOpts = copyOpts;
}
public WordTranslationsRepository(IDatabaseReader <WordTranslationsEntity> databaseReader, IDatabaseWriter <WordTranslationsEntity> databaseWriter) : base(databaseReader, databaseWriter)
{
}
private static DatabaseWriterConfiguration CreateLoggerConfigurationInstance(IDatabaseWriter config)
{
return(new DatabaseWriterConfiguration(ConvertLogLevel(config.LogLevel), config.ConnectionString, config.StoredProcedureName));
}
public Worker(ILogger <Worker> logger, IQueueReader reader, IDatabaseWriter writer)
{
_logger = logger;
_reader = reader;
_writer = writer;
}
public static Job CreateJob(IDatabaseSource src, IDatabaseWriter dst, DatabaseCopyOptions copyOpts, JobProperties jobProps)
{
return(Job.FromCommand(new CopyDbJobCommand(src, dst, copyOpts), jobProps));
}
public CollectionWriter(IDatabaseWriter databaseWriter, string collectionName)
{
_databaseWriter = databaseWriter;
_collectionName = collectionName;
}
public DocumentLogger(string category, IDatabaseWriter databaseWriter)
{
this.Category = category;
this.DatabaseWriter = databaseWriter;
}
public static void CopyDatabase(IDatabaseSource src, IDatabaseWriter dst, IProgressInfo progress, DatabaseCopyOptions copyOpts)
{
IDatabaseWriter dst2 = null;
for (; ;)
{
dst2 = dst.GetRedirectedWriter();
if (dst2 == null)
{
break;
}
dst = dst2;
}
dst.SetSourceInfo(new DatabaseWriterSourceInfo
{
Dialect = src.Dialect,
//CopyMode = copyOpts.Mode,
SchemaMode = copyOpts.SchemaMode,
});
try
{
dst.ProgressInfo = progress;
Async.SafeOpen(src.Connection);
dst.OpenConnection();
if (dst.DirectCopy(src))
{
dst.RunDirectCopy(src, copyOpts);
}
else
{
copyOpts.CopyMembers.IgnoreSystemObjects = true;
IDatabaseStructure tmpDb = src.InvokeLoadStructure(copyOpts.CopyMembers, progress);
DatabaseStructure sourceDb = new DatabaseStructure(tmpDb);
//sourceDb.AutoFillRefs();
DatabaseStructure targetDb = sourceDb.GetMappedDatabase(copyOpts, dst.Dialect);
if (dst.Dialect != null)
{
dst.Dialect.MigrateDatabase(targetDb, copyOpts.MigrationProfile, progress);
}
if (copyOpts.CopyStructure)
{
dst.WriteStructureBeforeData(targetDb);
}
bool copydata = copyOpts.DataMode != DbCopyDataMode.None && src.TableCaps.DataStoreForReading && dst.WriterCaps.AcceptData;
if (copydata)
{
dst.BeforeFillData();
foreach (var tbl in sourceDb.Tables.SortedByKey <ITableStructure, int>(tbl => copyOpts.DataCopyTables.IndexOf(tbl.FullName)))
{
if (!copyOpts.CopyTableData(tbl.FullName))
{
continue;
}
Logging.Debug("Copying table {0}", tbl);
if (progress != null)
{
progress.SetCurWork(String.Format("{0} {1}", Texts.Get("s_copying_table"), tbl));
}
GenericDataQueue queue = new GenericDataQueue(tbl, tbl, new IdentityTransform(tbl));
queue.ProgressInfo = progress;
if (dst.WriterCaps.ExecuteSql)
{
var ada = new RecordToDbAdapter(tbl, tbl, dst.Dialect, new DataFormatSettings());
ada.ProgressInfo = progress;
queue.AddOutputAdapter(ada);
}
ITableSource tsrc = src.GetTable(tbl.FullName);
ITabularDataStore srcds = tsrc.GetDataStoreAndReuse();
IAsyncResult async_src = srcds.BeginRead(null, queue);
ITableStructure newTableStruct = (ITableStructure)targetDb.FindByGroupId(tbl.GroupId);
dst.FillTable(newTableStruct, queue, copyOpts.TableOptions);
srcds.EndRead(async_src);
}
dst.AfterFillData();
}
if (copyOpts.CopyStructure)
{
dst.WriteStructureAfterData(targetDb);
}
}
}
catch (Exception)
{
dst.ProcessFailed();
throw;
}
finally
{
Async.SafeClose(src.Connection);
dst.CloseConnection();
}
}
public static void Run(IDatabaseSource source, IDatabaseWriter target)
{
CopyDbWizard wizard = new CopyDbWizard(source, target);
wizard.ShowDialogEx();
}
public CopyDbWizard(IDatabaseSource source, IDatabaseWriter target)
{
InitializeComponent();
addonSelectFrame1.Reload(true);
m_source = source;
m_target = target;
//selectTemplateComboFrame1.Configure(DatabaseWriterAddonType.Instance.CommonSpace, null, m_target != null ? ReflTools.GetRegisterType(m_target) : "dbk_writer", new List<string> { "s_select_in_tree" });
//selectTemplateComboFrame1.Enabled = true;
if (m_lastSelectedAddon != null)
{
addonSelectFrame1.DefaultAddonHolder = m_lastSelectedAddon;
}
treSource.TreeBehaviour.ShowFilter = node => node.IsDatabaseNodeOrParent();
if (m_source != null)
{
wizard1.Pages.Remove(wpSource);
if (m_source.Connection != null)
{
m_source.Connection.Owner = this;
}
m_isSourcePage = false;
}
else
{
treSource.RootPath = "data:";
}
if (m_target != null)
{
//m_target.OpenConnection();
if (m_target.ConfigurationNeeded)
{
addonSelectFrame1.SelectObjectImportant(m_target);
//propertyFrame1.SelectedObject = m_target;
}
else
{
wizard1.Pages.Remove(wpTarget);
m_isTargetPage = false;
}
if (!m_target.WriterCaps.AcceptData)
{
wizard1.Pages.Remove(wpDataProps);
m_isDataPage = false;
}
if (!m_target.WriterCaps.AcceptStructure)
{
wizard1.Pages.Remove(wpStructProps);
m_isStructPage = false;
}
}
Disposed += new EventHandler(CopyDbWizard_Disposed);
//m_created = true;
//if (m_target == null) RecreateWriter();
if (!m_isSourcePage && !m_isTargetPage && m_isStructPage)
{
InitStructPage();
}
if (!m_isSourcePage && !m_isTargetPage && !m_isStructPage && m_isDataPage)
{
InitDataPage();
}
}
public void Start()
{
m_databaseFileWriter = m_writerFactory(FileName);
m_databaseFileReader = m_readerFactory(FileName);
m_cacheProvider = m_cacheProviderFactory(FileName);
ulong timestamp;
m_documentStore = new DocumentStore(m_databaseFileReader.GetDocuments(out timestamp));
DBTimeStamp = timestamp;
}
public void Stop()
{
m_databaseFileWriter.Dispose();
m_databaseFileWriter = null;
m_databaseFileReader.Dispose();
m_databaseFileReader = null;
m_documentStore = null;
m_pendingTransaction.Clear();
m_pendingTransaction = null;
m_currentTransactionId = 0;
DBTimeStamp = 0;
}
