/// <summary> /// Method to delete a Namespace. /// </summary> /// <param name="ns">Namespace to delete.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> public void DeleteNamespace(string ns) { DatabaseParameter[] parameters = new DatabaseParameter[1]; parameters[0] = new DatabaseParameter("namespace", ns); _database.ExecuteNonQuery(CommandType.StoredProcedure, "DeleteNamespace", parameters); }
public void getDatabase(int id) { string resp = ""; try { connectModel(); DatabaseParameter database = systemConfigurationModel.getDatabase(id); database.Ip = encryptor.decryptData(database.Ip); database.Port = (database.Port != null) ? encryptor.decryptData(database.Port) : null; database.Instance = (database.Instance != null) ? encryptor.decryptData(database.Instance) : null; database.Name = encryptor.decryptData(database.Name); database.Username = encryptor.decryptData(database.Username); database.Password = encryptor.decryptData(database.Password); resp = serializeObject(database); } catch (Exception) { resp = "{\"type\":\"danger\", \"message\":\"Can not be loaded the database. Please try again.\"}"; } response(resp); }
/// <summary> /// Delete a specified topic. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the topic being deleted.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> public void DeleteTopic(string ns, string topicName) { DatabaseParameter[] parameters = new DatabaseParameter[2]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName); _database.ExecuteNonQuery(CommandType.StoredProcedure, "DeleteTopic", parameters); }
public static ParameterBase ParameterBase(DatabaseParameter parameterMetadata) { return(new ParameterBase() { Name = parameterMetadata.Name, Type = TypeBase(parameterMetadata.Type) }); }
public DatabaseParameterLink AppendCollection(DatabaseParameter parameter, DatabaseParameterRelation relation = DatabaseParameterRelation.AND) { var link = new DatabaseParameterLinkCollection(parameter, relation); Next = link; return(link.Content); }
private Objects.Database GenerateDatabase(DatabaseParameter param) { var db = new Objects.Database(); db.ConnectionString = param.ConnectionString; db.InitializeDatabase(); db.DatabaseToSchema(); return(db); }
public DatabaseParameterLinkCollection(DatabaseParameter parameter, DatabaseParameterRelation relation = DatabaseParameterRelation.AND) { var link = new DatabaseParameterLink() { Parameter = parameter }; Releation = relation; Content = link; }
private static Rubik.Database.Tools.DatabaseParameter GetParameters() { if (!File.Exists(_iniFilePath)) { string answer = AskQuestion(" > Ayar Dosyası Bulunamadı ! Otomatik Oluşturulsunmu ?<E,H>"); bool correct = false; //Gereksiz düzelt if (answer.ToUpper() == "EVET" || answer.ToUpper() == "HAYIR" || answer.ToUpper() == "E" || answer.ToUpper() == "H") { correct = true; } else { correct = false; } while (!correct) { answer = AskQuestion("\r > Seçenek Tanımlanamadı Geçerli Seçenekler <E,H>"); if (answer.ToUpper() == "EVET" || answer.ToUpper() == "HAYIR" || answer.ToUpper() == "E" || answer.ToUpper() == "H") { correct = true; } else { correct = false; } } if (correct) { WriteDefaultSettings(); Console.WriteLine("\r > Varsayılan ayarlar kaydedildi.Lütfen settings.ini dosyasından veritabanı ayarlarını düzenleyin"); } return(null); } else { DatabaseParameter param = new DatabaseParameter() { CreateTable = Convert.ToBoolean(ini.ReadValue("ExportParameters", "CreateTable", "True")), DropTable = Convert.ToBoolean(ini.ReadValue("ExportParameters", "DropTable", "False")), ExportColumns = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportColumns", "True")), ExportData = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportData", "False")), ExportIndexes = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportIndexes", "True")), ExportKeys = Convert.ToBoolean(ini.ReadValue("ExportParameters", "ExportKeys", "True")), AutoSave = Convert.ToBoolean(ini.ReadValue("ExportParameters", "AutoSave", "True")), FilePath = ini.ReadValue("ExportParameters", "FilePath", ""), ConnectionString = GetConnectionString("") }; return(param); } }
public DatabaseParameterLink Append(DatabaseParameter parameter, DatabaseParameterRelation relation = DatabaseParameterRelation.AND) { var link = new DatabaseParameterLink() { Parameter = parameter, Releation = relation }; Next = link; return(link); }
private static void Execute() { DatabaseParameter param = GetParameters(); if (param == null) { return; } string[] multipleUser = ini.ReadValue("Database", "User").Split(','); if (multipleUser.Count() > 1) { foreach (var item in multipleUser) { param.ConnectionString = GetConnectionString(item); var export = new Export(param); export.Execute(); } } else { try { var db = new Objects.Database(); db.ConnectionString = param.ConnectionString; db.InitializeDatabase(); db.DatabaseToSchema(); BinaryFormatter formatter = new BinaryFormatter(); FileStream fs = new FileStream(Path.Combine(Application.StartupPath, "Schema.bdb"), FileMode.OpenOrCreate, FileAccess.ReadWrite); formatter.Serialize(fs, db); fs.Flush(); fs.Close(); } catch (Exception) { } } //Rubik.Database.Tools.Export export = new Export(param); //export.Execute(); //} }
public bool Remove(DatabaseParameter item) { bool result = false; DatabaseParameter obj; for (int i = 0; i < _innerList.Count; i++) { obj = new DatabaseParameter(); obj = (DatabaseParameter)_innerList[i]; if (obj.ParameterName == item.ParameterName && obj.DataType == item.DataType) { _innerList.RemoveAt(i); result = true; break; } obj = null; } return(result); }
internal static DatabaseParameter[] ExtractDatabaseParameter(object o) { if (o == null) { return(Array.Empty <DatabaseParameter>()); } var properties = o.GetType().GetProperties(); var param = new DatabaseParameter[properties.Length]; for (var idx = 0; idx < properties.Length; idx++) { var property = properties[idx]; var name = property.Name; var value = property.GetValue(o); var parameter = new DatabaseParameter(name, value); param[idx] = parameter; } return(param); }
/// <inheritdoc /> public IEnumerable <T> List(T filterObject) { string procedureName; if (filterObject == null) { filterObject = new T(); } if (_defaultObject.Mappings.ContainsKey(Command.Select)) { procedureName = _defaultObject.Mappings[Command.Select]; } else { return(new List <T>()); } using (var dbContext = _dbContext.Create()) { var parametersToCreate = ReflectionHelper.GetSelectParameters <T>().ToList(); var parameters = new List <DatabaseParameter>(); foreach (var parameter in parametersToCreate) { var selectParamValue = parameter.GetValue(filterObject); var selectParamAttribute = parameter.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(SelectParameterAttribute)) as SelectParameterAttribute; if (selectParamAttribute == null || selectParamValue == null) { continue; } var dbParam = DatabaseParameter.CreateInParam(selectParamAttribute.ParamName, selectParamAttribute.Type, selectParamValue); parameters.Add(dbParam); } return(dbContext.ExecuteDataTable(procedureName, parameters).ToList <T>()); } }
/// <inheritdoc /> public bool Delete(T entity) { string procedureName; if (_defaultObject.Mappings.ContainsKey(Command.Delete)) { procedureName = _defaultObject.Mappings[Command.Delete]; } else { return(false); } using (var dbContext = _dbContext.Create()) { var parametersToCreate = ReflectionHelper.GetDeleteParameters <T>().ToList(); var parameters = new List <DatabaseParameter>(); foreach (var parameter in parametersToCreate) { var deleteParamValue = parameter.GetValue(entity); var deleteParamAttribute = parameter.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(DeleteParameterAttribute)) as DeleteParameterAttribute; if (deleteParamAttribute == null || deleteParamValue == null) { continue; } var dbParam = DatabaseParameter.CreateInParam(deleteParamAttribute.ParamName, deleteParamAttribute.Type, deleteParamValue); parameters.Add(dbParam); } dbContext.ExecuteNonQuery(procedureName, parameters); return(true); } }
/// <inheritdoc /> public void Add(T entity) { string procedureName; if (_defaultObject.Mappings.ContainsKey(Command.Insert)) { procedureName = _defaultObject.Mappings[Command.Insert]; } else { return; } using (var dbContext = _dbContext.Create()) { var parametersToCreate = ReflectionHelper.GetInsertParameters <T>().ToList(); var parameters = new List <DatabaseParameter>(); foreach (var parameter in parametersToCreate) { var insertParamValue = parameter.GetValue(entity); var insertParamAttribute = parameter.GetCustomAttributes(true).FirstOrDefault(x => x.GetType() == typeof(InsertParameterAttribute)) as InsertParameterAttribute; if (insertParamAttribute == null || insertParamValue == null) { continue; } var dbParam = DatabaseParameter.CreateInParam(insertParamAttribute.ParamName, insertParamAttribute.Type, insertParamValue); parameters.Add(dbParam); } var id = (T1)Convert.ChangeType(dbContext.ExecuteScalar(procedureName, parameters), typeof(T1)); entity.Id = id; } }
public int IndexOf(DatabaseParameter item) { return(_innerList.IndexOf(item)); }
/// <summary> /// Store the specified topic in the database. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the topic being saved.</param> /// <param name="lastWriteTime">The write time for the topic.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <param name="body">The contents of the topic being saved.</param> /// <param name="archive">Indicates if this is the archive record for the topic being saved.</param> public void WriteTopic(string ns, string topicName, DateTime lastWriteTime, string body, bool archive) { DatabaseParameter[] parameters = new DatabaseParameter[5]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName); parameters[2] = new DatabaseParameter("body", body); parameters[3] = new DatabaseParameter("archive", archive); parameters[4] = new DatabaseParameter("lastWriteTime", lastWriteTime); _database.ExecuteNonQuery(CommandType.StoredProcedure, "WriteTopic", parameters); }
/// <summary> /// Check if the Topic Exists in the namespace. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the topic.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <returns>Boolean value that indicates if the topic exists.</returns> public bool TopicExists(string ns, string topicName) { DatabaseParameter[] parameters = new DatabaseParameter[3]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName); parameters[2] = new DatabaseParameter("topicExists", SqlDbType.Bit); parameters[2].Direction = ParameterDirection.Output; _database.ExecuteScalar(CommandType.StoredProcedure, "CheckTopicExists", parameters); return BooleanConvert(parameters[2].Value.ToString()); }
/// <summary> /// Get the time when the topic was last updated. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the Topic.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <returns>Last Update Time for the topic.</returns> public DateTime GetTopicLastWriteTime(string ns, string topicName) { DatabaseParameter[] parameters = new DatabaseParameter[3]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName); parameters[2] = new DatabaseParameter("topicLastWriteTime", SqlDbType.DateTime); parameters[2].Direction = ParameterDirection.Output; _database.ExecuteScalar(CommandType.StoredProcedure, "GetTopicLastWriteTime", parameters); return (DateTime)parameters[2].Value; }
/// <summary> /// Get the contents of the topic. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the topic to fetch the topic body.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <returns>Returns the topic contents</returns> public string GetTopicBody(string ns, string topicName) { DatabaseParameter[] parameters = new DatabaseParameter[2]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName); return _database.ExecuteScalar(CommandType.StoredProcedure, "GetTopicBody", parameters) as string; }
private void CopyOutputParameter(SqlParameter sqlParameter, DatabaseParameter databaseParameter) { if (sqlParameter.Direction != ParameterDirection.Input) { databaseParameter.Value = sqlParameter.Value; } }
public int Add(string parametername, object value, ParameterDirection parameterdirection, SqlDbType datatype) { DatabaseParameter item = new DatabaseParameter(parametername, value, parameterdirection, datatype); return(_innerList.Add(item)); }
/// <summary> /// Get all the non archive topics in the specified namespace. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="sort">Boolean value to indicate if the topics need to be sorted in the /// descending order based on last write time.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <returns>Array of SqlTopicInfo containing the information for all non archive topics in the namespace.</returns> public SqlInfoForTopic[] GetSqlTopicInfoForNonArchiveTopics(string ns, bool sort) { ArrayList topicInfos = new ArrayList(); DatabaseParameter[] parameters = new DatabaseParameter[1]; parameters[0] = new DatabaseParameter("namespace", ns); string storedProcedureName = "GetSqlTopicInfoForNonArchiveTopics"; if (sort) { // To benefit from Sql compiled stored procedure cache using 2 different // stored procedures instead of passing the sort value thru to Sql. storedProcedureName = "GetSqlTopicInfoForNonArchiveTopicsSortedDescending"; } _database.ExecuteReader(CommandType.StoredProcedure, storedProcedureName, delegate(IDataReader reader) { while (reader.Read()) { SqlInfoForTopic topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1)); topicInfos.Add(topicInfo); } }, parameters); return (SqlInfoForTopic[])topicInfos.ToArray(typeof(SqlInfoForTopic)); }
public void Add(DatabaseParameter item) { _innerList.Add(item); }
public DbParameter[] ConvertParameter(DatabaseParameter[] parameters) { int len = parameters.Length; DbParameter[] paras = new DbParameter[len]; DbParameter p1 = null; int i = 0; foreach (DatabaseParameter p in parameters) { if (p.ProviderName == DatabaseProviders.SqlProvider) p1 = new SqlParameter(); else// if (p.ProviderName == DatabaseProviders.OracleProvider) p1 = new OracleParameter(); p1.DbType = p.DbType; p1.Direction = p.Direction; p1.ParameterName = p.ParameterName; if (p.Size != 0) p1.Size = p.Size; p1.SourceColumn = p.SourceColumn; p1.SourceColumnNullMapping = p.SourceColumnNullMapping; p.SourceVersion = DataRowVersion.Current; p1.SourceVersion = p.SourceVersion; p1.Value = p.Value; paras[i] = p1; i++; } return paras; }
private SqlParameter CreateParameter(DatabaseParameter parameter) { SqlParameter sqlParameter = new SqlParameter(); sqlParameter.Direction = parameter.Direction; sqlParameter.ParameterName = "@" + parameter.Name; sqlParameter.Value = parameter.Value; return sqlParameter; }
public bool Contains(DatabaseParameter item) { return(_innerList.Contains(item)); }
/// <summary> /// Gets all versions for the specified topic. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the topic to fetch the archive topics.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <returns>Array of SqlTopicInfo for all the archive versions of the specified topic.</returns> public SqlInfoForTopic[] GetSqlTopicInfosForTopic(string ns, string topicName) { ArrayList topicInfos = new ArrayList(); DatabaseParameter[] parameters = new DatabaseParameter[2]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName + "(%)"); // pattern for sql wild card search _database.ExecuteReader(CommandType.StoredProcedure, "GetSqlTopicArchiveInfos", delegate (IDataReader reader) { while (reader.Read()) { SqlInfoForTopic topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1)); topicInfos.Add(topicInfo); } }, parameters); return (SqlInfoForTopic[])topicInfos.ToArray(typeof(SqlInfoForTopic)); }
/// <summary> /// Get the latest version for the specified topic. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the topic.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <returns>SqlTopicInfo containing the topic information.</returns> public SqlInfoForTopic GetSqlTopicInfoForLatestTopicVersion(string ns, string topicName) { SqlInfoForTopic topicInfo = null; DatabaseParameter[] parameters = new DatabaseParameter[2]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName + "(%)"); // pattern for sql wild card search _database.ExecuteReader(CommandType.StoredProcedure, "GetSqlTopicInfoForLatestVersion", delegate(IDataReader reader) { while (reader.Read()) { topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1)); } }, parameters); return topicInfo; }
/// <summary> /// Gets all versions for the specified topic since the specified date and including the /// specified date. /// </summary> /// <param name="ns">Namespace of the topic.</param> /// <param name="topicName">Name of the topic to fetch the archive topics.</param> /// <param name="stamp">Datetime indicating the lower bound for topic last write time.</param> /// <param name="connectionString">Database Connectionstring to use for this namespace.</param> /// <returns>Array of SqlTopicInfo for all the archive versions of the specified topic.</returns> public SqlInfoForTopic[] GetSqlTopicInfosForTopicSince(string ns, string topicName, DateTime stamp) { ArrayList topicInfos = new ArrayList(); DatabaseParameter[] parameters = new DatabaseParameter[3]; parameters[0] = new DatabaseParameter("namespace", ns); parameters[1] = new DatabaseParameter("topicName", topicName + "(%)"); // pattern for sql wild card search // Sql allow only dates between January 1, 1753 through December 31, 9999 if (stamp.Year > 1800) { parameters[2] = new DatabaseParameter("stamp", stamp); } else { parameters[2] = new DatabaseParameter("stamp", new DateTime(1800, 1, 1)); } _database.ExecuteReader(CommandType.StoredProcedure, "GetSqlTopicArchiveInfosSince", delegate(IDataReader reader) { while (reader.Read()) { SqlInfoForTopic topicInfo = new SqlInfoForTopic(reader.GetString(0), reader.GetDateTime(1)); topicInfos.Add(topicInfo); } }, parameters); return (SqlInfoForTopic[])topicInfos.ToArray(typeof(SqlInfoForTopic)); }
public DatabaseParameterLink(DatabaseParameter parameter) { this.Parameter = parameter; }
protected DatabaseParameter[] ConvertParameter(DbParameter[] parameters) { int len = parameters.Length; DatabaseParameter[] paras = new DatabaseParameter[len]; //DatabaseParameter p = null; DatabaseParameter p1 = null; int i = 0; foreach (DbParameter p in parameters) { p1 = new DatabaseParameter(); if (p is SqlParameter) p1.ProviderName = DatabaseProviders.SqlProvider; p1.DbType = p.DbType; p1.Direction = p.Direction; p1.ParameterName = p.ParameterName; p1.Size = p.Size; p1.SourceColumn = p.SourceColumn; p1.SourceColumnNullMapping = p.SourceColumnNullMapping; p1.SourceVersion = p.SourceVersion; p1.Value = p.Value; paras[i] = p1; i++; Log.Dac("ConvertParameter:" + p1.ToKeyString()); } return paras; }