示例#1
0
 public override void InitDatabaseSchema()
 {
     using (var connection = UbjectDIBindings.Resolve <IDbConnection>(new ConstructorArgument[] { new ConstructorArgument("connectionString", ConnectionStringNoDb, false) }))
     {
         StringBuilder commandText = new StringBuilder();
         commandText.Append("CREATE DATABASE IF NOT EXISTS `" + SchemaName + "`;");
         connection.Open();
         IDbCommand command = connection.CreateCommand();
         command.CommandText = commandText.ToString();
         command.ExecuteNonQuery();
         connection.Close();
     }
 }
示例#2
0
        private void CreateCommand(StringBuilder commandText, Dictionary <string, object> parameters)
        {
            connection = Utilities.CreateDbConnection(dbManager);
            connection.Open();
            command = connection.CreateCommand();

            if (parameters != null)
            {
                foreach (KeyValuePair <string, object> parameter in parameters)
                {
                    List <ConstructorArgument> sqlParameters = new List <ConstructorArgument>();
                    sqlParameters.Add(new ConstructorArgument("parameterName", parameter.Key, false));
                    sqlParameters.Add(new ConstructorArgument("value", parameter.Value, false));
                    IDataParameter dataParameter = UbjectDIBindings.Resolve <IDataParameter>(sqlParameters.ToArray());
                    command.Parameters.Add(dataParameter);
                }
            }

            command.CommandText = commandText.ToString();
        }
        public override Dictionary <UbjectMetadata, object> GetObjects(Type type, List <Tuple <string, string, string> > filterProperties = null)
        {
            var           connection  = Utilities.CreateDbConnection(dbManager);
            IDbCommand    command     = connection.CreateCommand();
            StringBuilder commandText = new StringBuilder();

            var propertyInfo = type.GetPropertiesEx();

            commandText.Append(string.Format("{0} {1} {2} {3}", "SELECT", "*", "FROM", QueryTableName));

            string whereClause = BuildWhereClauses(type.GetPropertiesEx(), filterProperties);

            if (whereClause != string.Empty)
            {
                commandText.Append(string.Format(" {0} {1}", "WHERE", whereClause));
            }

            commandText.Append(";");

            foreach (var dataFieldEncapsultedParameter in dataFieldEncapsultedParameters)
            {
                command.Parameters.Add(new SQLiteParameter(dataFieldEncapsultedParameter.Value, dataFieldEncapsultedParameter.Key.Item2));
            }

            connection.Open();
            command.CommandText = commandText.ToString();

            IDataReader tableReader = command.ExecuteReader();

            Dictionary <UbjectMetadata, object> newObjects = new Dictionary <UbjectMetadata, object>();

            while (tableReader.Read())
            {
                object newObject = null;

                if (type.IsInterface)
                {
                    newObject = UbjectDIBindings.Resolve(type);
                }
                else
                {
                    newObject = Activator.CreateInstance(type);
                }

                var ubjectMetadata = new UbjectMetadata();

                for (int fieldIndex = 0; fieldIndex < tableReader.FieldCount; fieldIndex++)
                {
                    string fieldName  = tableReader.GetName(fieldIndex).ToString();
                    object fieldValue = tableReader.GetValue(fieldIndex);

                    if (UbjectMetadata.IsMetadataField(fieldName))
                    {
                        ubjectMetadata.SetPropertyValue(fieldName, fieldValue);
                    }
                    else
                    {
                        foreach (var property in propertyInfo)
                        {
                            if (fieldName.ToLower() == property.Name.ToLower())
                            {
                                if ((fieldValue != DBNull.Value) && (fieldValue != null))
                                {
                                    if (property.PropertyType.IsEnum)
                                    {
                                        property.SetValue(newObject, Enum.Parse(property.PropertyType, fieldValue.ToString()));
                                    }
                                    else
                                    {
                                        property.SetValue(newObject, Utilities.ChangeType(fieldValue, property.PropertyType));
                                    }
                                }

                                break;
                            }
                        }
                    }
                }

                newObjects.Add(ubjectMetadata, newObject);
            }

            connection.Close();

            return(newObjects);
        }