Beispiel #1
0
        public static string GetDeleteByIdSql(TableInfo tableInfo)
        {
            string strSql = "delete from {0} where {1} =" + AdoHelper.DbParmChar + tableInfo.Id.Key;
            strSql = string.Format(strSql, tableInfo.TableName, tableInfo.Id.Key);

            return strSql;
        }
        protected override ISession CreateAdminSession(IDatabase database)
        {
            using (var session = base.CreateAdminSession(database)) {
                using (var query = session.CreateQuery()) {
                    var tn1 = ObjectName.Parse("APP.test_table1");
                    var tableInfo1 = new TableInfo(tn1);
                    tableInfo1.AddColumn(new ColumnInfo("id", PrimitiveTypes.Integer()));
                    tableInfo1.AddColumn(new ColumnInfo("name", PrimitiveTypes.String()));
                    tableInfo1.AddColumn(new ColumnInfo("date", PrimitiveTypes.DateTime()));
                    query.CreateTable(tableInfo1);
                    query.AddPrimaryKey(tn1, "id");

                    var tn2 = ObjectName.Parse("APP.test_table2");
                    var tableInfo2 = new TableInfo(tn2);
                    tableInfo2.AddColumn(new ColumnInfo("id", PrimitiveTypes.Integer()));
                    tableInfo2.AddColumn(new ColumnInfo("other_id", PrimitiveTypes.Integer()));
                    tableInfo2.AddColumn(new ColumnInfo("count", PrimitiveTypes.Integer()));
                    query.CreateTable(tableInfo2);
                    query.AddPrimaryKey(tn2, "id");
                    query.AddForeignKey(tn2, new[] { "other_id" }, tn1, new[] { "id" }, ForeignKeyAction.Cascade, ForeignKeyAction.Cascade, null);

                    query.Commit();
                }
            }

            return base.CreateAdminSession(database);
        }
Beispiel #3
0
        public void CreateSimpleTableAsAdmin()
        {
            var tableName = ObjectName.Parse("APP.test_table");
            var tableInfo = new TableInfo(tableName);
            tableInfo.AddColumn("a", PrimitiveTypes.Integer(), true);
            tableInfo.AddColumn("b", PrimitiveTypes.String());

            using (var session = Database.CreateUserSession(AdminUserName, AdminPassword)) {
                using (var context = new SessionQueryContext(session)) {
                    Assert.DoesNotThrow(() => {
                        context.CreateTable(tableInfo);
                    });
                }

                Assert.DoesNotThrow(() => session.Commit());
            }

            using (var session = Database.CreateUserSession(AdminUserName, AdminPassword)) {
                using (var context = new SessionQueryContext(session)) {
                    bool exists = false;
                    Assert.DoesNotThrow(() => exists = context.TableExists(tableName));
                    Assert.IsTrue(exists);
                }
            }
        }
 public TableQueryInfo(IUserSession session, TableInfo tableInfo, ObjectName tableName, ObjectName aliasName)
 {
     Session = session;
     TableInfo = tableInfo;
     TableName = tableName;
     AliasName = aliasName;
 }
		public override string GetAutoIncrementExpression(TableInfo ti)
		{
			if (!string.IsNullOrEmpty(ti.SequenceName))
				return string.Format("{0}.nextval", ti.SequenceName);

			return null;
		}
        public void TestSetup()
        {
            var tableInfo = new TableInfo(ObjectName.Parse("APP.people"));
            tableInfo.AddColumn("id", PrimitiveTypes.Bit());
            tableInfo.AddColumn("first_name", PrimitiveTypes.String(), true);
            tableInfo.AddColumn("last_name", PrimitiveTypes.String());
            tableInfo.AddColumn("age", PrimitiveTypes.TinyInt());
            table = new TemporaryTable(tableInfo);

            var tempTable = (TemporaryTable) table;
            tempTable.NewRow(new[] {
                DataObject.BigInt(1),
                DataObject.String("Antonello"),
                DataObject.String("Provenzano"),
                DataObject.Null()
            });
            tempTable.NewRow(new[] {
                DataObject.BigInt(2),
                DataObject.String("Moritz"),
                DataObject.String("Krull"),
                DataObject.TinyInt(31)
            });

            tempTable.BuildIndexes();
        }
        public void Create()
        {
            // SYSTEM.ROUTINE
            var tableInfo = new TableInfo(SystemSchema.RoutineTableName);
            tableInfo.AddColumn("schema", PrimitiveTypes.String());
            tableInfo.AddColumn("name", PrimitiveTypes.String());
            tableInfo.AddColumn("type", PrimitiveTypes.String());
            tableInfo.AddColumn("location", PrimitiveTypes.String());
            tableInfo.AddColumn("return_type", PrimitiveTypes.String());
            tableInfo.AddColumn("username", PrimitiveTypes.String());
            transaction.CreateTable(tableInfo);

            // SYSTEM.ROUTINE_PARAM
            tableInfo = new TableInfo(SystemSchema.RoutineParameterTableName);
            tableInfo.AddColumn("schema", PrimitiveTypes.String());
            tableInfo.AddColumn("name", PrimitiveTypes.String());
            tableInfo.AddColumn("arg_name", PrimitiveTypes.String());
            tableInfo.AddColumn("arg_type", PrimitiveTypes.String());
            tableInfo.AddColumn("in_out", PrimitiveTypes.String());
            tableInfo.AddColumn("offset", PrimitiveTypes.Integer());
            transaction.CreateTable(tableInfo);

            var fkCol = new[] {"routine_schema", "routine_name"};
            var refCol = new[] {"schema", "name"};
            const ForeignKeyAction onUpdate = ForeignKeyAction.NoAction;
            const ForeignKeyAction onDelete = ForeignKeyAction.Cascade;

            transaction.AddForeignKey(SystemSchema.RoutineParameterTableName, fkCol, SystemSchema.RoutineTableName, refCol,
                onDelete, onUpdate, "ROUTINE_PARAMS_FK");
        }
Beispiel #8
0
        protected override void DoRun()
        {
            var tables = Connection.GetSchema("Tables");
            var columns = new List<DataRow>();
            foreach (DataRow row in Connection.GetSchema("Columns").Rows) columns.Add(row);
            columns = new List<DataRow>(columns.SortedByKey<DataRow, int>(c => c.SafeInt("ORDINAL_POSITION")));

            foreach (DataRow row in tables.Rows)
            {
                if (row.SafeString("TABLE_TYPE") != "BASE TABLE") continue;
                var table = new TableInfo(Result);
                table.FullName = new NameWithSchema(row.SafeString("TABLE_SCHEMA"), row.SafeString("TABLE_NAME"));
                Result.Tables.Add(table);
                _tables[table.FullName] = table;
            }

            foreach (DataRow row in columns)
            {
                if (row.SafeString("TABLE_TYPE") != "BASE TABLE") continue;
                var tname = new NameWithSchema(row.SafeString("TABLE_SCHEMA"), row.SafeString("TABLE_NAME"));
                var table = _tables[tname];
                var col = new ColumnInfo(table);
                col.Name = row.SafeString("COLUMN_NAME");
                col.NotNull = row.SafeString("IS_NULLABLE") == "NO";
                col.DataType = row.SafeString("DATA_TYPE");
                col.Length = row.SafeInt("CHARACTER_MAXIMUM_LENGTH");
                col.Precision = row.SafeInt("NUMERIC_PRECISION");
                col.Scale = row.SafeInt("NUMERIC_SCALE");
                col.DefaultValue = row.SafeString("COLUMN_DEFAULT");
                table.Columns.Add(col);
            }
        }
        public IObjectInfo CreateObjectInfo(Type forType)
        {
            if (forType == null)
            {
                throw new ArgumentNullException("forType");
            }

            var tableAttribute = forType.GetAttribute<TableAttribute>(inherit: false);

            if (tableAttribute == null)
            {
                throw new MappingException(ExceptionMessages.AttributeMappingConvention_NoTableAttribute.FormatWith(forType.FullName));
            }

            var identifierStrategy = IdentifierStrategy.DbGenerated;
            var columns = this.CreateColumnInfos(forType, ref identifierStrategy);

            var tableInfo = new TableInfo(columns, identifierStrategy, tableAttribute.Name, tableAttribute.Schema);

            if (this.log.IsDebug)
            {
                this.log.Debug(LogMessages.MappingConvention_MappingTypeToTable, forType.FullName, tableInfo.Schema, tableInfo.Name);
            }

            return new PocoObjectInfo(forType, tableInfo);
        }
    internal static TableInfo GetTableInfo( Type t )
    {
      TableInfo table;
      if ( _tableNameCache.TryGetValue( t, out table ) ) return table;

      table = new TableInfo();
      table.TableName = t.Name;
      table.SchemaName = "dbo";

      // check for an attribute specifying something different
      var tableAttribute = t.GetCustomAttribute<TableAttribute>( false );
      if ( tableAttribute != null )
      {
        table.TableName = tableAttribute.Name;
        if ( !string.IsNullOrWhiteSpace( tableAttribute.Schema ) ) table.SchemaName = tableAttribute.Schema;
      }

      // get the property names that can be mapped
      foreach ( var pi in t.GetProperties( System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public ).Where( m => m.CanRead && m.CanWrite && !m.HasCustomAttribute<NotMappedAttribute>( false ) ) )
        table.FieldNames.Add( GetFieldName( pi ) );

      // get the key property names
      foreach ( var pi in t.GetProperties( System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public ).Where( m => m.CanRead && m.CanWrite && m.HasCustomAttribute<System.ComponentModel.DataAnnotations.KeyAttribute>( false )  ) )
        table.PrimaryKeyFieldNames.Add( GetFieldName( pi ) );

      // try to add the newly aquired info
      if ( _tableNameCache.TryAdd( t, table ) ) return table;
      return _tableNameCache[ t ];
    }
 private void CreateTable(IQuery query)
 {
     var tableInfo = new TableInfo(ObjectName.Parse("APP.test_table"));
     tableInfo.AddColumn("a", PrimitiveTypes.Integer());
     tableInfo.AddColumn("b", PrimitiveTypes.String(), false);
     query.CreateTable(tableInfo, false, false);
 }
        static SessionTableContainer()
        {
            // SYSTEM.OPEN_SESSIONS
            OpenSessionsTableInfo = new TableInfo(SystemSchema.OpenSessionsTableName);
            OpenSessionsTableInfo.AddColumn("username", PrimitiveTypes.String());
            OpenSessionsTableInfo.AddColumn("host_string", PrimitiveTypes.String());
            OpenSessionsTableInfo.AddColumn("last_command", PrimitiveTypes.DateTime());
            OpenSessionsTableInfo.AddColumn("time_connected", PrimitiveTypes.DateTime());
            OpenSessionsTableInfo = OpenSessionsTableInfo.AsReadOnly();

            // SYSTEM.SESSION_INFO
            SessionInfoTableInfo = new TableInfo(SystemSchema.SessionInfoTableName);
            SessionInfoTableInfo.AddColumn("var", PrimitiveTypes.String());
            SessionInfoTableInfo.AddColumn("value", PrimitiveTypes.String());
            SessionInfoTableInfo = SessionInfoTableInfo.AsReadOnly();

            // SYSTEM.STATS
            StatisticsTableInfo = new TableInfo(SystemSchema.StatisticsTableName);
            StatisticsTableInfo.AddColumn("stat_name", PrimitiveTypes.String());
            StatisticsTableInfo.AddColumn("value", PrimitiveTypes.String());
            StatisticsTableInfo = StatisticsTableInfo.AsReadOnly();

            IntTableInfo = new TableInfo[3];
            IntTableInfo[0] = StatisticsTableInfo;
            IntTableInfo[1] = SessionInfoTableInfo;
            IntTableInfo[2] = OpenSessionsTableInfo;
        }
Beispiel #13
0
 public void GetTableInfo(Type t, TableInfo ti)
 {
     if (t == typeof(Poco2))
     {
         ti.TableName = "petapoco";
         ti.PrimaryKey = "id";
     }
 }
Beispiel #14
0
 private bool IsTableDropped(IEnumerable<RelationalModelChange> changes, TableInfo table)
 {
     return CollectionUtils.Contains(changes,
         delegate(RelationalModelChange c)
         {
             return c is DropTableChange && Equals(c.Table, table);
         });
 }
        public TableInfoListViewItem(TableInfo table)
        {
            this.Table = table;
            if (table == null) return;

            this.Name = table.Name;
            this.Text = $"{table.Name} ({table.TotalRecords})";
        }
Beispiel #16
0
        protected override bool OnSetUp(string testName, IQuery query)
        {
            var tableInfo = new TableInfo(ObjectName.Parse("APP.test_table"));
            tableInfo.AddColumn("a", PrimitiveTypes.Integer());

            query.Access().CreateObject(tableInfo);
            return true;
        }
        public ForeignKeyBuilder(string name, TableInfo referencedTable)
            : base(name)
        {
            targetTable = referencedTable.Name;
              targetColName = referencedTable.PrimaryKeyName;

              base.colType = referencedTable.PrimaryKeyType;
              base.size = referencedTable.PrimaryKeySize;
        }
Beispiel #18
0
        public FunctionTable(ITable table, SqlExpression[] functionList, string[] columnNames, IRequest queryContext)
            : base(queryContext.Context)
        {
            // Make sure we are synchronized over the class.
            lock (typeof(FunctionTable)) {
                uniqueId = uniqueKeySeq;
                ++uniqueKeySeq;
            }

            uniqueId = (uniqueId & 0x0FFFFFFF) | 0x010000000;

            context = queryContext;

            ReferenceTable = table;
            varResolver = table.GetVariableResolver();
            varResolver = varResolver.ForRow(0);

            // Create a DataTableInfo object for this function table.
            funTableInfo = new TableInfo(FunctionTableName);

            expList = new SqlExpression[functionList.Length];
            expInfo = new byte[functionList.Length];

            // Create a new DataColumnInfo for each expression, and work out if the
            // expression is simple or not.
            for (int i = 0; i < functionList.Length; ++i) {
                var expr = functionList[i];
                // Examine the expression and determine if it is simple or not
                if (expr.IsConstant() && !expr.HasAggregate(context)) {
                    // If expression is a constant, solve it
                    var result = expr.Evaluate(context, null);
                    if (result.ExpressionType != SqlExpressionType.Constant)
                        throw new InvalidOperationException();

                    expr = result;
                    expList[i] = expr;
                    expInfo[i] = 1;
                } else {
                    // Otherwise must be dynamic
                    expList[i] = expr;
                    expInfo[i] = 0;
                }

                // Make the column info
                funTableInfo.AddColumn(columnNames[i], expr.ReturnType(context, varResolver));
            }

            // Make sure the table info isn't changed from this point on.
            funTableInfo = funTableInfo.AsReadOnly();

            // routine tables are the size of the referring table.
            rowCount = table.RowCount;

            // Set schemes to 'blind search'.
            SetupIndexes(DefaultIndexTypes.BlindSearch);
        }
        public void Ctor_Sets_JsonConverter_And_TableInfo()
        {
            var jsonConverter = new JilJsonConverter();
            var info = new TableInfo();

            var convention = new StoreConventions(jsonConverter, info);

            convention.JsonConverter.ShouldBeSameAs(jsonConverter);
            convention.TableInfo.ShouldBeSameAs(info);
        }
Beispiel #20
0
 protected override IQuery CreateQuery(ISession session)
 {
     var query = base.CreateQuery(session);
     var tableInfo = new TableInfo(TestTableName);
     tableInfo.AddColumn("id", PrimitiveTypes.Integer());
     tableInfo.AddColumn("name", PrimitiveTypes.String());
     tableInfo.AddColumn("date", PrimitiveTypes.DateTime());
     query.CreateTable(tableInfo);
     return query;
 }
Beispiel #21
0
        public ViewInfo(TableInfo tableInfo, SqlQueryExpression queryExpression, IQueryPlanNode queryPlan)
        {
            if (tableInfo == null)
                throw new ArgumentNullException("tableInfo");
            if (queryExpression == null)
                throw new ArgumentNullException("queryExpression");

            TableInfo = tableInfo;
            QueryExpression = queryExpression;
            QueryPlan = queryPlan;
        }
Beispiel #22
0
        protected override IQueryContext CreateQueryContext(IDatabase database)
        {
            var context = base.CreateQueryContext(database);

            var tableInfo = new TableInfo(TestTableName);
            tableInfo.AddColumn("id", PrimitiveTypes.Integer());
            tableInfo.AddColumn("name", PrimitiveTypes.String());
            tableInfo.AddColumn("date", PrimitiveTypes.DateTime());

            return context;
        }
        private IMutableTable CreateTable()
        {
            var tableName = ObjectName.Parse("APP.test_table");
            var tableInfo = new TableInfo(tableName);
            tableInfo.AddColumn("name", PrimitiveTypes.String(), true);
            tableInfo.AddColumn("age", PrimitiveTypes.Integer());
            tableInfo.AddColumn("order", PrimitiveTypes.Integer());

            Query.CreateTable(tableInfo);
            return Query.GetMutableTable(tableName);
        }
Beispiel #24
0
 public void OnTableCompositeSetup(IQuery systemQuery)
 {
     var tableInfo = new TableInfo(SystemSchema.GrantsTableName);
     tableInfo.AddColumn("priv_bit", PrimitiveTypes.Numeric());
     tableInfo.AddColumn("object", PrimitiveTypes.Numeric());
     tableInfo.AddColumn("name", PrimitiveTypes.String());
     tableInfo.AddColumn("grantee", PrimitiveTypes.String());
     tableInfo.AddColumn("grant_option", PrimitiveTypes.Boolean());
     tableInfo.AddColumn("granter", PrimitiveTypes.String());
     tableInfo = tableInfo.AsReadOnly();
     systemQuery.Access().CreateSystemTable(tableInfo);
 }
Beispiel #25
0
        public static IFields CreateFields(TableInfo tInfo)
        {
            if (tInfo == null || tInfo.FieldsInfo == null || tInfo.FieldsInfo.Count == 0)
                return null;

            IFieldsEdit fields=new FieldsClass();
            foreach (FieldInfo fInfo in tInfo.FieldsInfo)
            {
                fields.AddField(CreateField(fInfo));
            }
            return fields;
        }
Beispiel #26
0
        public void Create()
        {
            var tableInfo = new TableInfo(SystemSchema.ViewTableName);
            tableInfo.AddColumn("schema", PrimitiveTypes.String());
            tableInfo.AddColumn("name", PrimitiveTypes.String());
            tableInfo.AddColumn("query", PrimitiveTypes.String());
            tableInfo.AddColumn("plan", PrimitiveTypes.Binary());

            // TODO: Columns...

            Transaction.CreateTable(tableInfo);
        }
Beispiel #27
0
 public void Create()
 {
     var tableInfo = new TableInfo(SystemSchema.TriggerTableName);
     tableInfo.AddColumn("schema", PrimitiveTypes.String());
     tableInfo.AddColumn("name", PrimitiveTypes.String());
     tableInfo.AddColumn("type", PrimitiveTypes.Integer());
     tableInfo.AddColumn("on_object", PrimitiveTypes.String());
     tableInfo.AddColumn("action", PrimitiveTypes.Integer());
     tableInfo.AddColumn("args", PrimitiveTypes.Binary());
     tableInfo.AddColumn("procedure_name", PrimitiveTypes.String());
     transaction.CreateTable(tableInfo);
 }
Beispiel #28
0
        public void setupConfig( IDatabase db )
        {
            // We want to find the impexporter config file.
            string nunitPath = TestContext.CurrentContext.WorkDirectory;
            string configPath = Path.Combine( nunitPath, "..", "..", "..", "config.xml" );
            _cfg = XmlPersistence.Load<ImpExporterConfig>( configPath );

            // Create the database itself.
            _db = db;

            _ti = new TableInfo();
        }
Beispiel #29
0
 public void Create()
 {
     // SYSTEM.SCHEMA_INFO
     var tableInfo = new TableInfo(SystemSchema.SchemaInfoTableName);
     tableInfo.AddColumn("id", PrimitiveTypes.Numeric());
     tableInfo.AddColumn("name", PrimitiveTypes.String());
     tableInfo.AddColumn("type", PrimitiveTypes.String());
     tableInfo.AddColumn("culture", PrimitiveTypes.String());
     tableInfo.AddColumn("other", PrimitiveTypes.String());
     tableInfo = tableInfo.AsReadOnly();
     Transaction.CreateTable(tableInfo);
 }
        private static TableInfo CreateTableInfo(string schema, string name)
        {
            var tableInfo = new TableInfo(new ObjectName(new ObjectName(schema), name));

            tableInfo.AddColumn("type", PrimitiveTypes.Numeric());
            tableInfo.AddColumn("on_object", PrimitiveTypes.String());
            tableInfo.AddColumn("routine_name", PrimitiveTypes.String());
            tableInfo.AddColumn("param_args", PrimitiveTypes.String());
            tableInfo.AddColumn("owner", PrimitiveTypes.String());

            return tableInfo.AsReadOnly();
        }
Beispiel #31
0
        public FluentMappingsPocoData(Type t, TypeDefinition typeConfig, IMapper mapper)
        {
            Mapper    = mapper;
            type      = t;
            TableInfo = new TableInfo();

            // Get the table name
            var a = typeConfig.TableName ?? "";

            TableInfo.TableName = a.Length == 0 ? t.Name : a;

            // Get the primary key
            a = typeConfig.PrimaryKey ?? "";
            TableInfo.PrimaryKey = a.Length == 0 ? "ID" : a;

            a = typeConfig.SequenceName ?? "";
            TableInfo.SequenceName = a.Length == 0 ? null : a;

            TableInfo.AutoIncrement = typeConfig.AutoIncrement ?? true;

            // Set autoincrement false if primary key has multiple columns
            TableInfo.AutoIncrement = TableInfo.AutoIncrement ? !TableInfo.PrimaryKey.Contains(',') : TableInfo.AutoIncrement;

            // Call column mapper
            if (mapper != null)
            {
                mapper.GetTableInfo(t, TableInfo);
            }

            // Work out bound properties
            bool explicitColumns = typeConfig.ExplicitColumns ?? false;

            Columns = new Dictionary <string, PocoColumn>(StringComparer.OrdinalIgnoreCase);
            foreach (var mi in ReflectionUtils.GetFieldsAndPropertiesForClasses(t))
            {
                // Work out if properties is to be included
                var isColumnDefined = typeConfig.ColumnConfiguration.ContainsKey(mi.Name);
                if (explicitColumns)
                {
                    if (!isColumnDefined)
                    {
                        continue;
                    }
                }
                else
                {
                    if (isColumnDefined && (typeConfig.ColumnConfiguration[mi.Name].IgnoreColumn.HasValue && typeConfig.ColumnConfiguration[mi.Name].IgnoreColumn.Value))
                    {
                        continue;
                    }
                }

                var pc = new PocoColumn();
                pc.MemberInfo = mi;

                // Work out the DB column name
                if (isColumnDefined)
                {
                    var colattr = typeConfig.ColumnConfiguration[mi.Name];
                    pc.ColumnName = colattr.DbColumnName;
                    if (colattr.ResultColumn.HasValue && colattr.ResultColumn.Value)
                    {
                        pc.ResultColumn = true;
                    }
                    else if (colattr.VersionColumn.HasValue && colattr.VersionColumn.Value)
                    {
                        pc.VersionColumn = true;
                    }

                    if (colattr.ForceUtc.HasValue && colattr.ForceUtc.Value)
                    {
                        pc.ForceToUtc = true;
                    }

                    if (TableInfo.PrimaryKey.Split(',').Contains(mi.Name))
                    {
                        TableInfo.PrimaryKey = (pc.ColumnName ?? mi.Name) + ",";
                    }

                    pc.ColumnType = colattr.DbColumnType;
                }
                if (pc.ColumnName == null)
                {
                    pc.ColumnName = mi.Name;
                    if (mapper != null && !mapper.MapMemberToColumn(mi, ref pc.ColumnName, ref pc.ResultColumn))
                    {
                        continue;
                    }
                }

                // Store it
                Columns.Add(pc.ColumnName, pc);
            }

            // Trim trailing slash if built using Property names
            TableInfo.PrimaryKey = TableInfo.PrimaryKey.TrimEnd(',');

            // Build column list for automatic select
            QueryColumns = (from c in Columns where !c.Value.ResultColumn select c.Key).ToArray();
        }
Beispiel #32
0
        private void ConfigurePrimaryKeyCollisionResolution_Click(TableInfo tableInfo)
        {
            var dialog = new ConfigurePrimaryKeyCollisionResolverUI(tableInfo, _activator);

            dialog.ShowDialog(this);
        }
        public override async Task <object> InsertAsync <T>(IDbConnection connection, TableInfo tableInfo, T data, Type tType, IDbTransaction transaction = null)
        {
            var count = await connection.ExecuteAsync(GetInsertSql(tableInfo, tType.FullName), data, transaction);

            if (!tableInfo.AutoIncrement)
            {
                return(count);
            }
            return(await connection.ExecuteScalarAsync("Select LAST_INSERT_ID()", transaction : transaction));
        }
Beispiel #34
0
 internal PostgreSqlIndexInfo(TableInfo parent)
     : base(parent)
 {
     _delimiter = "";
 }
Beispiel #35
0
 public static void AuditDataValue(object sender, IEnumerable <T1> data, IFreeSql orm, TableInfo table, Dictionary <string, bool> changedDict)
 {
     if (data?.Any() != true)
     {
         return;
     }
     foreach (var d in data)
     {
         AuditDataValue(sender, d, orm, table, changedDict);
     }
 }
Beispiel #36
0
 public void GetTableInfo(Type t, TableInfo ti)
 {
 }
Beispiel #37
0
        protected void SetupLowPrivilegeUserRightsFor(TableInfo ti, TestLowPrivilegePermissions permissions)
        {
            var db = DataAccessPortal.GetInstance().ExpectDatabase(ti, DataAccessContext.InternalDataProcessing);

            SetupLowPrivilegeUserRightsFor(db, permissions, ti);
        }
Beispiel #38
0
        public void Initialize(ProjectConfig config)
        {
            this.config = config;
            Tables      = new List <TableInfo>();

            #region dir

            CheckNotNull.NotEmpty(config.ContextName, nameof(config.ContextName));

            if (config.Mode == GeneralInfo.Db)
            {
                CheckNotNull.NotEmpty(config.OutputDir, nameof(config.OutputDir));
                Config = new GeneralConfig
                {
                    OutputDir   = config.OutputDir,
                    ProjectName = config.ContextName,
                    ModelPath   = config.OutputDir
                };

                if (!Directory.Exists(Config.ModelPath))
                {
                    Directory.CreateDirectory(Config.ModelPath);
                }
            }
            #endregion

            #region Schemas
            string[] filters = new string[this.Filters.Count];
            for (int i = 0; i < Filters.Count; i++)
            {
                filters[i] = $"'{Filters[i]}'";
            }

            string        sql     = $@"SELECT schema_name FROM information_schema.schemata WHERE SCHEMA_NAME NOT IN({string.Join(",", filters)}) ORDER BY SCHEMA_NAME; ";
            List <string> schemas = new List <string>();
            SQLContext.ExecuteDataReader(dr =>
            {
                schemas.Add(dr[0].ToString());
            }, CommandType.Text, sql);
            #endregion

            #region Tables
            foreach (var schema in schemas)
            {
                string _sqltext = $@"SELECT table_name,'table' as type FROM INFORMATION_SCHEMA.tables WHERE table_schema='{schema}' AND table_type='BASE TABLE'
UNION ALL
SELECT table_name,'view' as type FROM INFORMATION_SCHEMA.views WHERE table_schema = '{schema}'";
                SQLContext.ExecuteDataReader(dr =>
                {
                    var table = new TableInfo()
                    {
                        Schema = schema,
                        Name   = dr["table_name"].ToString(),
                        Type   = dr["type"].ToString() == "table" ? TableType.Table : TableType.View
                    };
                    GetFields(table);
                    Tables.Add(table);
                }, CommandType.Text, _sqltext);
            }
            #endregion
        }
Beispiel #39
0
 public static void AuditDataValue(object sender, IEnumerable <T1> data, IFreeSql orm, TableInfo table, Dictionary <string, bool> changedDict)
 {
     if (data?.Any() != true)
     {
         return;
     }
     if (orm.Aop.AuditValueHandler == null)
     {
         return;
     }
     foreach (var d in data)
     {
         if (d == null)
         {
             continue;
         }
         foreach (var col in table.Columns.Values)
         {
             object val       = col.GetMapValue(d);
             var    auditArgs = new Aop.AuditValueEventArgs(Aop.AuditValueType.Update, col, table.Properties[col.CsName], val);
             orm.Aop.AuditValueHandler(sender, auditArgs);
             if (auditArgs.IsChanged)
             {
                 col.SetMapValue(d, val = auditArgs.Value);
                 if (changedDict != null && changedDict.ContainsKey(col.Attribute.Name) == false)
                 {
                     changedDict.Add(col.Attribute.Name, true);
                 }
             }
         }
     }
 }
Beispiel #40
0
        public override bool UpdateTableInfo(string oldTableName, TableInfo oldTableInfo, List <string> contentTableNameList, out string newTableName, out TableInfo newTableInfo)
        {
            ConvertInfo converter = null;

            var oldTableNameWithoutPrefix = oldTableName.Substring(oldTableName.IndexOf("_", StringComparison.Ordinal) + 1);

            if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableAdministrator.OldTableName))
            {
                converter = TableAdministrator.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableAdministratorsInRoles.OldTableName))
            {
                converter = TableAdministratorsInRoles.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableArea.OldTableName))
            {
                converter = TableArea.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableChannel.OldTableName))
            {
                converter = TableChannel.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableChannelGroup.OldTableName))
            {
                converter = TableChannelGroup.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableConfig.OldTableName))
            {
                converter = TableConfig.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableContentCheck.OldTableName))
            {
                converter = TableContentCheck.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableContentGroup.OldTableName))
            {
                converter = TableContentGroup.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableDbCache.OldTableName))
            {
                converter = TableDbCache.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableDepartment.OldTableName))
            {
                converter = TableDepartment.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableErrorLog.OldTableName))
            {
                converter = TableErrorLog.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableKeyword.OldTableName))
            {
                converter = TableKeyword.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableLog.OldTableName))
            {
                converter = TableLog.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TablePermissionsInRoles.OldTableName))
            {
                converter = TablePermissionsInRoles.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableRelatedField.OldTableName))
            {
                converter = TableRelatedField.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableRelatedFieldItem.OldTableName))
            {
                converter = TableRelatedFieldItem.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableRole.OldTableName))
            {
                converter = TableRole.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableSite.OldTableName))
            {
                converter = TableSite.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableSiteLog.OldTableName))
            {
                converter = TableSiteLog.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableSitePermissions.OldTableName))
            {
                converter = TableSitePermissions.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTable.OldTableName))
            {
                converter = TableTable.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTableMetadata.OldTableName))
            {
                converter = TableTableMetadata.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTableStyle.OldTableName))
            {
                converter = TableTableStyle.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTableStyleItem.OldTableName))
            {
                converter = TableTableStyleItem.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTag.OldTableName))
            {
                converter = TableTag.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTemplate.OldTableName))
            {
                converter = TableTemplate.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTemplateLog.OldTableName))
            {
                converter = TableTemplateLog.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableTemplateMatch.OldTableName))
            {
                converter = TableTemplateMatch.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableUser.OldTableName))
            {
                converter = TableUser.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovInteractChannel.OldTableName))
            {
                converter = TableGovInteractChannel.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovInteractLog.OldTableName))
            {
                converter = TableGovInteractLog.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovInteractPermissions.OldTableName))
            {
                converter = TableGovInteractPermissions.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovInteractRemark.OldTableName))
            {
                converter = TableGovInteractRemark.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovInteractReply.OldTableName))
            {
                converter = TableGovInteractReply.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovInteractType.OldTableName))
            {
                converter = TableGovInteractType.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovPublicCategory.OldTableName))
            {
                converter = TableGovPublicCategory.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovPublicCategoryClass.OldTableName))
            {
                converter = TableGovPublicCategoryClass.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovPublicIdentifierRule.OldTableName))
            {
                converter = TableGovPublicIdentifierRule.Converter;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableNameWithoutPrefix, TableGovPublicIdentifierSeq.OldTableName))
            {
                converter = TableGovPublicIdentifierSeq.Converter;
            }
            else if (StringUtils.ContainsIgnoreCase(contentTableNameList, oldTableName))
            {
                converter = TableContent.GetConverter(oldTableName, oldTableInfo.Columns);
            }

            return(GetNewTableInfo(oldTableName, oldTableInfo, converter, out newTableName, out newTableInfo));
        }
Beispiel #41
0
    public static bool ExportTableToJavaClass(TableInfo tableInfo, out string errorString)
    {
        StringBuilder    stringBuilder = new StringBuilder();
        int              level         = 0;
        bool             isAddImport   = false;
        List <FieldInfo> allFieldInfo  = tableInfo.GetAllClientFieldInfo();

        // 先生成package
        stringBuilder.AppendLine(string.Concat("package ", AppValues.ExportJavaClassPackage, ";"));
        // package与下面内容空一行
        stringBuilder.AppendLine();

        // 再生成import内容
        if (AppValues.ExportJavaClassImport != null)
        {
            for (int i = 0; i < AppValues.ExportJavaClassImport.Count; ++i)
            {
                string importString = AppValues.ExportJavaClassImport[i];
                stringBuilder.AppendLine(string.Concat("import ", importString, ";"));
            }

            isAddImport = true;
        }
        // 如果实际用到了array、dict或时间型,但没有声明对相应类库的引用,就要强制添加
        if (AppValues.ExportJavaClassImport == null || !AppValues.ExportJavaClassImport.Contains(_ARRAY_DATA_TYPE_IMPORT_STRING))
        {
            foreach (FieldInfo fieldInfo in allFieldInfo)
            {
                if (fieldInfo.DataType == DataType.Array)
                {
                    stringBuilder.AppendLine(string.Concat("import ", _ARRAY_DATA_TYPE_IMPORT_STRING, ";"));
                    isAddImport = true;
                    break;
                }
            }
        }
        if (AppValues.ExportJavaClassImport == null || !AppValues.ExportJavaClassImport.Contains(_DICT_DATA_TYPE_IMPORT_STRING))
        {
            foreach (FieldInfo fieldInfo in allFieldInfo)
            {
                if (fieldInfo.DataType == DataType.Dict)
                {
                    stringBuilder.AppendLine(string.Concat("import ", _DICT_DATA_TYPE_IMPORT_STRING, ";"));
                    isAddImport = true;
                    break;
                }
            }
        }
        bool isNeedDateTypeImport = false;

        foreach (FieldInfo fieldInfo in allFieldInfo)
        {
            if (fieldInfo.DataType == DataType.Date || fieldInfo.DataType == DataType.Time)
            {
                isNeedDateTypeImport = true;
                break;
            }
        }
        if (isNeedDateTypeImport == true && AppValues.ExportJavaClassIsUseDate == true && (AppValues.ExportJavaClassImport == null || !AppValues.ExportJavaClassImport.Contains(_DATE_DATA_TYPE_TO_DATE_IMPORT_STRING)))
        {
            stringBuilder.AppendLine(string.Concat("import ", _DATE_DATA_TYPE_TO_DATE_IMPORT_STRING, ";"));
            isAddImport = true;
        }
        if (isNeedDateTypeImport == true && AppValues.ExportJavaClassIsUseDate == false && (AppValues.ExportJavaClassImport == null || !AppValues.ExportJavaClassImport.Contains(_DATE_DATA_TYPE_TO_CALENDAR_IMPORT_STRING)))
        {
            stringBuilder.AppendLine(string.Concat("import ", _DATE_DATA_TYPE_TO_CALENDAR_IMPORT_STRING, ";"));
            isAddImport = true;
        }
        // package与类定义行之间通常需要空一行
        if (isAddImport == true)
        {
            stringBuilder.AppendLine();
        }

        // 最后根据字段信息生成csv对应的Java类
        // 优先使用表格config中指定的Java类名,若未设置则自动命名
        string className = null;

        if (tableInfo.TableConfig != null && tableInfo.TableConfig.ContainsKey(AppValues.CONFIG_NAME_EXPORT_CSV_CLASS_NAME) && tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT_CSV_CLASS_NAME].Count > 0 && !string.IsNullOrEmpty(tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT_CSV_CLASS_NAME][0].Trim()))
        {
            className = tableInfo.TableConfig[AppValues.CONFIG_NAME_EXPORT_CSV_CLASS_NAME][0].Trim();
        }
        if (string.IsNullOrEmpty(className))
        {
            // 自动命名采用驼峰式
            className = Utils.GetCamelCaseString(tableInfo.TableName);

            // 若统一配置了前缀和后缀,需进行添加(但注意如果配置了前缀,上面生成的驼峰式类名首字母要改为大写)
            if (string.IsNullOrEmpty(AppValues.ExportCsvClassClassNamePrefix) == false)
            {
                className = string.Concat(AppValues.ExportCsvClassClassNamePrefix, char.ToUpper(className[0]), className.Substring(1));
            }
            if (string.IsNullOrEmpty(AppValues.ExportCsvClassClassNamePostfix) == false)
            {
                className = className + AppValues.ExportCsvClassClassNamePostfix;
            }
        }

        // 类名首字母大写
        char firstLetter = char.ToUpper(className[0]);

        className = string.Concat(firstLetter, className.Substring(1));
        stringBuilder.AppendLine(string.Concat("public class ", className, " {"));
        // 逐个生成类字段信息
        ++level;
        foreach (FieldInfo fieldInfo in allFieldInfo)
        {
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.Append("private ");
            stringBuilder.Append(_GetJavaClassFieldDefine(fieldInfo));
            stringBuilder.AppendLine(string.Concat(" ", fieldInfo.FieldName, ";"));
        }
        // 字段声明与下面内容空一行
        stringBuilder.AppendLine();
        // 为每个字段生成get、set方法
        foreach (FieldInfo fieldInfo in allFieldInfo)
        {
            stringBuilder.Append(_GetJavaClassIndentation(level));
            // get方法
            stringBuilder.Append("public ");
            stringBuilder.Append(_GetJavaClassFieldDefine(fieldInfo));
            stringBuilder.AppendLine(string.Concat(" get", fieldInfo.FieldName.Substring(0, 1).ToUpper(), fieldInfo.FieldName.Substring(1), "() {"));
            ++level;
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.AppendLine(string.Concat("return ", fieldInfo.FieldName, ";"));
            --level;
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.AppendLine("}");
            // 与set函数空一行
            stringBuilder.AppendLine();
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.Append("public void ");
            stringBuilder.AppendLine(string.Concat("set", fieldInfo.FieldName.Substring(0, 1).ToUpper(), fieldInfo.FieldName.Substring(1), "(", _GetJavaClassFieldDefine(fieldInfo), " ", fieldInfo.FieldName, ") {"));
            ++level;
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.AppendLine(string.Concat("this.", fieldInfo.FieldName, " = ", fieldInfo.FieldName, ";"));
            --level;
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.AppendLine("}");
        }
        // 无参构造函数
        if (AppValues.ExportJavaClassisGenerateConstructorWithoutFields == true)
        {
            stringBuilder.AppendLine();
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.AppendLine(string.Concat("public ", className, "() {"));
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.AppendLine("}");
        }
        // 含全部参数的构造函数
        if (AppValues.ExportJavaClassIsGenerateConstructorWithAllFields == true)
        {
            stringBuilder.AppendLine();
            stringBuilder.Append(_GetJavaClassIndentation(level));
            List <string> allFieldDataTypeAndName = new List <string>();
            foreach (FieldInfo fieldInfo in allFieldInfo)
            {
                allFieldDataTypeAndName.Add(string.Concat(_GetJavaClassFieldDefine(fieldInfo), " ", fieldInfo.FieldName));
            }

            stringBuilder.AppendLine(string.Concat("public ", className, "(", Utils.CombineString(allFieldDataTypeAndName, ", "), ") {"));
            ++level;
            foreach (FieldInfo fieldInfo in allFieldInfo)
            {
                stringBuilder.Append(_GetJavaClassIndentation(level));
                stringBuilder.AppendLine(string.Concat("this.", fieldInfo.FieldName, " = ", fieldInfo.FieldName, ";"));
            }
            --level;
            stringBuilder.Append(_GetJavaClassIndentation(level));
            stringBuilder.AppendLine("}");
        }

        --level;
        // 闭合类定义
        stringBuilder.AppendLine("}");

        if (Utils.SaveJavaClassFile(tableInfo.TableName, className, stringBuilder.ToString()) == true)
        {
            errorString = null;
            return(true);
        }
        else
        {
            errorString = "保存csv对应Java类文件失败\n";
            return(false);
        }
    }
Beispiel #42
0
        public static void Sort(TableInfo table, byte[] data)
        {
            Debug.Assert(data.Length % table.RowSize == 0);

            var recs = new Record[data.Length / table.RowSize];

            for (int i = 0, offs = 0; i < recs.Length; i++, offs += table.RowSize)
            {
                var d = new byte[table.RowSize];
                recs[i] = new Record(i, d);
                Array.Copy(data, offs, d, 0, d.Length);
            }

            switch (table.Table)
            {
            case Table.CustomAttribute:
            case Table.FieldMarshal:
            case Table.EventMap:
            case Table.PropertyMap:
            case Table.MethodImpl:
            case Table.NestedClass:
            case Table.GenericParamConstraint:
                Array.Sort(recs, (a, b) => {
                    uint ac = Read(table, a.Data, 0);
                    uint bc = Read(table, b.Data, 0);
                    if (ac != bc)
                    {
                        return(ac.CompareTo(bc));
                    }
                    return(a.OrigIndex.CompareTo(b.OrigIndex));
                });
                break;

            case Table.DeclSecurity:
            case Table.FieldLayout:
            case Table.ImplMap:
            case Table.FieldRVA:
                Array.Sort(recs, (a, b) => {
                    uint ac = Read(table, a.Data, 1);
                    uint bc = Read(table, b.Data, 1);
                    if (ac != bc)
                    {
                        return(ac.CompareTo(bc));
                    }
                    return(a.OrigIndex.CompareTo(b.OrigIndex));
                });
                break;

            case Table.Constant:
            case Table.ClassLayout:
            case Table.MethodSemantics:
                Array.Sort(recs, (a, b) => {
                    // Constant: Parent column is 2 and not 1 because a 'pad' column has been inserted
                    uint ac = Read(table, a.Data, 2);
                    uint bc = Read(table, b.Data, 2);
                    if (ac != bc)
                    {
                        return(ac.CompareTo(bc));
                    }
                    return(a.OrigIndex.CompareTo(b.OrigIndex));
                });
                break;

            case Table.InterfaceImpl:
                Array.Sort(recs, (a, b) => {
                    uint ac = Read(table, a.Data, 0);
                    uint bc = Read(table, b.Data, 0);
                    if (ac != bc)
                    {
                        return(ac.CompareTo(bc));
                    }
                    ac = Read(table, a.Data, 1);
                    bc = Read(table, b.Data, 1);
                    if (ac != bc)
                    {
                        return(ac.CompareTo(bc));
                    }
                    return(a.OrigIndex.CompareTo(b.OrigIndex));
                });
                break;

            case Table.GenericParam:
                Array.Sort(recs, (a, b) => {
                    uint ac = Read(table, a.Data, 2);
                    uint bc = Read(table, b.Data, 2);
                    if (ac != bc)
                    {
                        return(ac.CompareTo(bc));
                    }
                    ac = Read(table, a.Data, 0);
                    bc = Read(table, b.Data, 0);
                    if (ac != bc)
                    {
                        return(ac.CompareTo(bc));
                    }
                    return(a.OrigIndex.CompareTo(b.OrigIndex));
                });
                break;

            default:
                Debug.Fail("Can't sort it. Call CanSort() first");
                return;
            }

            for (int i = 0, offs = 0; i < recs.Length; i++, offs += table.RowSize)
            {
                var d = recs[i].Data;
                Array.Copy(d, 0, data, offs, d.Length);
            }
        }
Beispiel #43
0
        protected override bool TryPrepareValue(IDbConnection connection, ColumnMapper columnMapper, TableInfo table, string columnName, ref object value)
        {
            if (table.Name == "crm_invoice" && columnName == "json_data")
            {
                var data = JObject.Parse((string)value);

                var oldValue = Convert.ToInt32(data["LogoBase64Id"]);
                if (oldValue != 0)
                {
                    data["LogoBase64Id"] = Convert.ToInt32(columnMapper.GetMapping("crm_organisation_logo", "id", oldValue));
                }

                oldValue = Convert.ToInt32(data["DeliveryAddressID"]);
                if (oldValue != 0)
                {
                    data["DeliveryAddressID"] = Convert.ToInt32(columnMapper.GetMapping("crm_contact_info", "id", oldValue));
                }

                oldValue = Convert.ToInt32(data["BillingAddressID"]);
                if (oldValue != 0)
                {
                    data["BillingAddressID"] = Convert.ToInt32(columnMapper.GetMapping("crm_contact_info", "id", oldValue));
                }

                value = data.ToString();

                return(true);
            }

            return(base.TryPrepareValue(connection, columnMapper, table, columnName, ref value));
        }
Beispiel #44
0
 /// <summary>
 /// Records parameters from the <see cref="TableInfo"/> at the appropriate <see cref="ParameterLevel"/>
 /// </summary>
 public void AddParametersFor(TableInfo tableInfo)
 {
     AddParametersFor(tableInfo, ParametersFoundSoFarInQueryGeneration[ParameterLevel.TableInfo]);
 }
        protected override bool TryPrepareValue(IDbConnection connection, ColumnMapper columnMapper, TableInfo table, string columnName, IEnumerable <RelationInfo> relations, ref object value)
        {
            var relationList = relations.ToList();

            if (relationList.All(x => x.ChildTable == "files_security" && x.ChildColumn == "subject"))
            {
                //note: value could be ShareForEveryoneID and in that case result should be always false
                var strVal = Convert.ToString(value);
                if (Helpers.IsEmptyOrSystemUser(strVal) || Helpers.IsEmptyOrSystemGroup(strVal))
                {
                    return(true);
                }

                foreach (var relation in relationList)
                {
                    var mapping = columnMapper.GetMapping(relation.ParentTable, relation.ParentColumn, value);
                    if (mapping != null)
                    {
                        value = mapping;
                        return(true);
                    }
                }
                return(false);
            }
            return(base.TryPrepareValue(connection, columnMapper, table, columnName, relationList, ref value));
        }
Beispiel #46
0
 public AddColumn(SqlSyntax scriptGen, PropertyInfo propertyInfo) : base(scriptGen, ObjectType.Column, ActionType.Create, $"{propertyInfo.QualifiedName()}")
 {
     _propertyInfo = propertyInfo;
     _modelType    = propertyInfo.ReflectedType;
     _tableInfo    = Syntax.GetTableInfoFromType(_modelType);
 }
        protected override bool TryPrepareRow(IDbConnection connection, ColumnMapper columnMapper, TableInfo table, DataRowInfo row, out Dictionary <string, object> preparedRow)
        {
            if (row.TableName == "files_thirdparty_id_mapping")
            {
                //todo: think...
                preparedRow = new Dictionary <string, object>();

                object folderId = null;

                var sboxId = Regex.Replace(row[1].ToString(), @"(?<=sbox-)\d+", match =>
                {
                    folderId = columnMapper.GetMapping("files_thirdparty_account", "id", match.Value);
                    return(Convert.ToString(folderId));
                }, RegexOptions.Compiled);

                if (folderId == null)
                {
                    return(false);
                }

                var hashBytes = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(sboxId));
                var hashedId  = BitConverter.ToString(hashBytes).Replace("-", "").ToLower();

                preparedRow.Add("hash_id", hashedId);
                preparedRow.Add("id", sboxId);
                preparedRow.Add("tenant_id", columnMapper.GetTenantMapping());

                columnMapper.SetMapping("files_thirdparty_id_mapping", "hash_id", row["hash_id"], hashedId);

                return(true);
            }

            return(base.TryPrepareRow(connection, columnMapper, table, row, out preparedRow));
        }
Beispiel #48
0
        private void WriteRecords(Database db, string path)
        {
            TransformView transform = null;

            if (db.Tables.Contains(TransformView.TableName))
            {
                transform = new TransformView(db);
            }

            string query = null;

            try
            {
                query = this.GetQuery(db, path);
            }
            catch (PSArgumentException ex)
            {
                base.WriteError(ex.ErrorRecord);
                return;
            }

            if (!string.IsNullOrEmpty(query))
            {
                using (var view = db.OpenView(query))
                {
                    view.Execute();

                    // Get column information from the view before being disposed.
                    var columns = ViewManager.GetColumns(view);

                    var record = view.Fetch();
                    while (null != record)
                    {
                        using (record)
                        {
                            // Create a locally cached copy of the record.
                            var copy = new Record(record, columns, transform, path);
                            var obj  = PSObject.AsPSObject(copy);

                            // Show only column properties by default.
                            var memberSet = ViewManager.GetMemberSet(view);
                            obj.Members.Add(memberSet, true);

                            this.WriteObject(obj);
                        }

                        record = view.Fetch();
                    }
                }
            }
            else
            {
                foreach (var table in db.Tables)
                {
                    if (db.IsTablePersistent(table.Name))
                    {
                        var info = new TableInfo(table.Name, path, transform, this.Patch, this.Transform);
                        var obj  = PSObject.AsPSObject(info);

                        this.WriteObject(obj);
                    }
                }
            }
        }
Beispiel #49
0
 public void SelectTableInfo(TableInfo toSelect)
 {
     tlvTableInfos.SelectObject(toSelect);
 }
Beispiel #50
0
        protected override void DoRunAnalysis()
        {
            foreach (var table in Structure.Tables)
            {
                _tables[table.FullName]     = table;
                _tablesById[table.ObjectId] = table;
            }

            foreach (var view in Structure.Views)
            {
                _viewsById[view.ObjectId] = view;
            }

            var dialect = Factory.CreateDialect();

            if (FilterOptions.AnyTables && IsTablesPhase)
            {
                Timer("tables...");
                try
                {
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("tables.sql", tables: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            int modifyIndex = reader.GetOrdinal("modify_date");
                            int createIndex = reader.GetOrdinal("modify_date");
                            while (reader.Read())
                            {
                                string   tname  = reader.SafeString("TableName");
                                string   schema = reader.SafeString("SchemaName");
                                string   id     = reader.SafeString("object_id");
                                DateTime modify = reader.GetDateTime(modifyIndex);
                                DateTime create = reader.GetDateTime(createIndex);

                                if (_tablesById.ContainsKey(id))
                                {
                                    var table = _tablesById[id];
                                    table.FullName   = new NameWithSchema(schema, tname);
                                    table.ModifyDate = modify;
                                }
                                else
                                {
                                    var table = new TableInfo(Structure)
                                    {
                                        FullName   = new NameWithSchema(schema, tname),
                                        ObjectId   = id,
                                        ModifyDate = modify,
                                        CreateDate = create,
                                    };
                                    Structure.Tables.Add(table);
                                    _tables[table.FullName]     = table;
                                    _tablesById[table.ObjectId] = table;
                                }
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading tables", err);
                }

                Timer("columns...");

                try
                {
                    using (var cmd = Connection.CreateCommand())
                    {
                        string sql = CreateQuery("columns.sql", tables: true);
                        if (ServerVersion.Is_2008() && String.IsNullOrEmpty(LinkedServerName))
                        {
                            sql = sql.Replace("#2008#", ",c.is_sparse");
                        }
                        else
                        {
                            sql = sql.Replace("#2008#", "");
                        }
                        cmd.CommandText = sql;
                        using (var reader = cmd.ExecuteReader())
                        {
                            int sparseIndex;
                            try { sparseIndex = reader.GetOrdinal("is_sparse"); }
                            catch { sparseIndex = -1; }

                            while (reader.Read())
                            {
                                string tid = reader.SafeString("object_id");
                                if (!_tablesById.ContainsKey(tid))
                                {
                                    continue;
                                }
                                var table = _tablesById[tid];
                                var col   = new ColumnInfo(table);
                                col.Name     = reader.SafeString("column_name");
                                col.NotNull  = reader.SafeString("is_nullable") != "True";
                                col.DataType = reader.SafeString("type_name");
                                string dataTypeName = col.DataType;
                                int    bytelen      = reader.SafeString("max_length").SafeIntParse();
                                int    length       = 0;
                                if (col.DataType.ToLower().Contains("nchar") || col.DataType.ToLower().Contains("nvarchar"))
                                {
                                    length = bytelen >= 0 ? bytelen / 2 : bytelen;
                                }
                                else if (col.DataType.ToLower().Contains("char") || col.DataType.ToLower().Contains("binary"))
                                {
                                    length = bytelen;
                                }
                                int precision = reader.SafeString("precision").SafeIntParse();
                                int scale     = reader.SafeString("scale").SafeIntParse();

                                var dt = col.DataType.ToLower();
                                if (dt.Contains("char") || dt.Contains("binary"))
                                {
                                    if (length > 0)
                                    {
                                        col.DataType += $"({length})";
                                    }
                                    if (length < 0)
                                    {
                                        col.DataType += $"(max)";
                                    }
                                }
                                if (dt.Contains("num") || dt.Contains("dec"))
                                {
                                    col.DataType += $"({precision},{scale})";
                                }

                                col.DefaultValue       = SimplifyExpression(reader.SafeString("default_value"));
                                col.DefaultConstraint  = reader.SafeString("default_constraint");
                                col.AutoIncrement      = reader.SafeString("is_identity") == "True";
                                col.ComputedExpression = SimplifyExpression(reader.SafeString("computed_expression"));
                                col.IsPersisted        = reader.SafeString("is_persisted") == "True";
                                col.IsSparse           = sparseIndex >= 0 ? reader[sparseIndex]?.ToString()?.ToLower() == "true" : false;
                                col.ObjectId           = reader.SafeString("column_id");
                                col.CommonType         = AnalyseType(dataTypeName, length, precision, scale);
                                table.Columns.Add(col);
                                if (String.IsNullOrWhiteSpace(col.ComputedExpression))
                                {
                                    col.ComputedExpression = null;
                                }
                                if (String.IsNullOrWhiteSpace(col.DefaultValue))
                                {
                                    col.DefaultValue      = null;
                                    col.DefaultConstraint = null;
                                }
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading columns", err);
                }

                try
                {
                    Timer("primary keys...");
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("primary_keys.sql", tables: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                string table  = reader.SafeString("TableName");
                                string schema = reader.SafeString("SchemaName");
                                string column = reader.SafeString("ColumnName");
                                string cnt    = reader.SafeString("ConstraintName");
                                var    t      = _tables[new NameWithSchema(schema, table)];
                                t.ColumnByName(column).PrimaryKey = true;

                                if (t.PrimaryKey == null)
                                {
                                    t.PrimaryKey = new PrimaryKeyInfo(t);
                                    t.PrimaryKey.ConstraintName = cnt;
                                }
                                t.PrimaryKey.Columns.Add(new ColumnReference {
                                    RefColumn = t.ColumnByName(column)
                                });
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading primary keys", err);
                }

                try
                {
                    Timer("foreign keys...");
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("foreign_keys.sql", tables: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                string fktable  = reader.SafeString("FK_Table");
                                string fkcolumn = reader.SafeString("FK_Column");
                                string fkschema = reader.SafeString("FK_Schema");

                                string pktable = reader.SafeString("IX_Table");
                                if (String.IsNullOrEmpty(pktable))
                                {
                                    pktable = reader.SafeString("PK_Table");
                                }
                                string pkcolumn = reader.SafeString("IX_Column");
                                //if (String.IsNullOrEmpty(pkcolumn)) pkcolumn = reader.SafeString("PK_Column");
                                string pkschema = reader.SafeString("IX_Schema");
                                if (String.IsNullOrEmpty(pkschema))
                                {
                                    pkschema = reader.SafeString("PK_Schema");
                                }

                                string deleteAction = reader.SafeString("Delete_Action");
                                string updateAction = reader.SafeString("Update_Action");

                                string cname = reader.SafeString("Constraint_Name");

                                var fkt = _tables[new NameWithSchema(fkschema, fktable)];
                                var pkt = _tables[new NameWithSchema(pkschema, pktable)];
                                var fk  = fkt.ForeignKeys.Find(f => f.ConstraintName == cname);
                                if (fk == null)
                                {
                                    fk = new ForeignKeyInfo(fkt)
                                    {
                                        ConstraintName = cname, RefTable = pkt
                                    };
                                    fkt.ForeignKeys.Add(fk);
                                    fk.OnDeleteAction = ForeignKeyActionExtension.FromSqlName(deleteAction);
                                    fk.OnUpdateAction = ForeignKeyActionExtension.FromSqlName(updateAction);
                                }
                                fk.Columns.Add(new ColumnReference
                                {
                                    RefColumn = fkt.ColumnByName(fkcolumn)
                                });
                                fk.RefColumns.Add(new ColumnReference
                                {
                                    RefColumn = pkt.ColumnByName(pkcolumn)
                                });
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading foreign keys", err);
                }

                var indexById = new Dictionary <string, ColumnsConstraintInfo>();

                try
                {
                    Timer("indexes...");
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("getindexes.sql", tables: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                string oid                = reader.SafeString("object_id");
                                string ixname             = reader.SafeString("ix_name");
                                string typedesc           = (reader.SafeString("type_desc") ?? "").ToLower();
                                bool   isunique           = reader.SafeString("is_unique") == "True";
                                string indexid            = reader.SafeString("index_id");
                                bool   isUniqueConstraint = reader.SafeString("is_unique_constraint") == "True";

                                var table = _tablesById.Get(oid);
                                if (table == null)
                                {
                                    continue;
                                }
                                if (isUniqueConstraint)
                                {
                                    var unique = new UniqueInfo(table);
                                    unique.ObjectId                = indexid;
                                    unique.ConstraintName          = ixname;
                                    indexById[oid + "|" + indexid] = unique;
                                    table.Uniques.Add(unique);
                                }
                                else
                                {
                                    var index = new IndexInfo(table);
                                    index.ObjectId       = indexid;
                                    index.IsUnique       = isunique;
                                    index.ConstraintName = ixname;
                                    switch (typedesc)
                                    {
                                    case "clustered":
                                        index.IndexType = DbIndexType.Clustered;
                                        break;

                                    case "xml":
                                        index.IndexType = DbIndexType.Xml;
                                        break;

                                    case "spatial":
                                        index.IndexType = DbIndexType.Spatial;
                                        break;

                                    case "fulltext":
                                        index.IndexType = DbIndexType.Fulltext;
                                        break;
                                    }
                                    indexById[oid + "|" + indexid] = index;
                                    table.Indexes.Add(index);
                                }
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading indexes", err);
                }

                try
                {
                    Timer("index columns...");
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("getindexcols.sql", tables: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                string oid     = reader.SafeString("object_id");
                                string indexid = reader.SafeString("index_id");
                                string colid   = reader.SafeString("column_id");
                                bool   desc    = reader.SafeString("is_descending_key") == "True";
                                bool   inc     = reader.SafeString("is_included_column") == "True";

                                var index = indexById.Get(oid + "|" + indexid);
                                if (index == null)
                                {
                                    continue;
                                }
                                var col = index.OwnerTable.Columns.FirstOrDefault(x => x.ObjectId == colid);
                                if (col == null)
                                {
                                    continue;
                                }

                                index.Columns.Add(new ColumnReference
                                {
                                    RefColumn    = col,
                                    IsDescending = desc,
                                    IsIncluded   = inc,
                                });
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading index columns", err);
                }

                try
                {
                    Timer("check constraints...");
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("getchecks.sql", tables: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                string oid  = reader.SafeString("object_id");
                                string name = reader.SafeString("name");
                                string def  = SimplifyExpression(reader.SafeString("definition"));

                                var table = _tablesById.Get(oid);
                                if (table == null)
                                {
                                    continue;
                                }

                                var check = new CheckInfo(table)
                                {
                                    ConstraintName = name,
                                    Definition     = def,
                                };

                                table.Checks.Add(check);
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading check constraints", err);
                }
            }


            var objs = new Dictionary <NameWithSchema, string>();

            if ((FilterOptions.AnyFunctions || FilterOptions.AnyStoredProcedures || FilterOptions.AnyViews || FilterOptions.AnyTriggers) && (IsViewsPhase || IsFunctionsPhase))
            {
                try
                {
                    Timer("sql code...");
                    // load code text
                    using (var cmd = Connection.CreateCommand())
                    {
                        string sql;
                        if (Phase == DatabaseAnalysePhase.All)
                        {
                            sql = CreateQuery("loadsqlcode.sql", views: true, procedures: true, functions: true, triggers: true);
                            sql = sql.Replace("#TYPECOND#", "1=1");
                        }
                        else
                        {
                            sql = CreateQuery("loadsqlcode.sql", views: IsViewsPhase, procedures: IsFunctionsPhase, functions: IsFunctionsPhase, triggers: IsFunctionsPhase);
                            var types = new List <string>();
                            if (IsViewsPhase)
                            {
                                types.Add("V");
                            }
                            if (IsFunctionsPhase)
                            {
                                types.Add("P");
                                types.Add("IF");
                                types.Add("FN");
                                types.Add("TF");
                                types.Add("TR");
                            }
                            sql = sql.Replace("#TYPECOND#", "s.type in (" + types.Select(x => "'" + x + "'").CreateDelimitedText(",") + ")");
                        }
                        cmd.CommandText = sql;
                        using (var reader = cmd.ExecuteReader())
                        {
                            NameWithSchema lastName = null;
                            while (reader.Read())
                            {
                                var    name = new NameWithSchema(reader.SafeString("OBJ_SCHEMA"), reader.SafeString("OBJ_NAME"));
                                string text = reader.SafeString("CODE_TEXT") ?? "";
                                if (lastName != null && name == lastName)
                                {
                                    objs[name] += text;
                                }
                                else
                                {
                                    lastName   = name;
                                    objs[name] = text;
                                }
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading SQL code", err);
                }
            }

            if (FilterOptions.AnyViews && IsViewsPhase)
            {
                try
                {
                    Timer("views...");
                    // load views
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("loadviews.sql", views: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            int modifyIndex = reader.GetOrdinal("modify_date");
                            int createIndex = reader.GetOrdinal("modify_date");
                            while (reader.Read())
                            {
                                var      name   = new NameWithSchema(reader.SafeString("Schema"), reader.SafeString("Name"));
                                string   id     = reader.SafeString("object_id");
                                DateTime modify = reader.GetDateTime(modifyIndex);
                                DateTime create = reader.GetDateTime(createIndex);

                                var view = new ViewInfo(Structure)
                                {
                                    FullName   = name,
                                    ObjectId   = id,
                                    ModifyDate = modify,
                                    CreateDate = create,
                                };
                                if (objs.ContainsKey(name))
                                {
                                    view.CreateSql = objs[name];
                                }
                                Structure.Views.Add(view);
                                _viewsById[view.ObjectId] = view;
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading views", err);
                }
            }

            if (FilterOptions.AnyTriggers && IsFunctionsPhase)
            {
                try
                {
                    Timer("triggers...");
                    // load triggers
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("gettriggers.sql", triggers: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            int modifyIndex = reader.GetOrdinal("modify_date");
                            int createIndex = reader.GetOrdinal("modify_date");
                            while (reader.Read())
                            {
                                var      name     = new NameWithSchema(reader.SafeString("schema"), reader.SafeString("name"));
                                string   id       = reader.SafeString("object_id");
                                string   parentId = reader.SafeString("parent_id");
                                DateTime modify   = reader.GetDateTime(modifyIndex);
                                DateTime create   = reader.GetDateTime(createIndex);

                                var trg = new TriggerInfo(Structure)
                                {
                                    FullName   = name,
                                    ObjectId   = id,
                                    ModifyDate = modify,
                                    CreateDate = create,
                                };
                                if (objs.ContainsKey(name))
                                {
                                    trg.CreateSql = objs[name];
                                }
                                trg.RelatedTable = _tablesById.Get(parentId);
                                trg.RelatedView  = _viewsById.Get(parentId);
                                Structure.Triggers.Add(trg);
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading triggers", err);
                }
            }

            if ((FilterOptions.AnyStoredProcedures || FilterOptions.AnyFunctions) && IsFunctionsPhase)
            {
                try
                {
                    Timer("programmables...");
                    var programmables = new Dictionary <NameWithSchema, ProgrammableInfo>();

                    // load procedures and functions
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText = CreateQuery("programmables.sql", procedures: true, functions: true);
                        using (var reader = cmd.ExecuteReader())
                        {
                            int modifyIndex = reader.GetOrdinal("modify_date");
                            int createIndex = reader.GetOrdinal("modify_date");

                            while (reader.Read())
                            {
                                var              name   = new NameWithSchema(reader.SafeString("schema"), reader.SafeString("name"));
                                string           id     = reader.SafeString("object_id");
                                DateTime         modify = reader.GetDateTime(modifyIndex);
                                DateTime         create = reader.GetDateTime(createIndex);
                                ProgrammableInfo info   = null;
                                string           type   = reader.SafeString("type");
                                switch (type.Trim())
                                {
                                case "P":
                                    info = new StoredProcedureInfo(Structure);
                                    break;

                                case "FN":
                                    info = new FunctionInfo(Structure)
                                    {
                                        HasTableResult = false,
                                    };
                                    break;

                                case "IF":
                                case "TF":
                                    info = new FunctionInfo(Structure)
                                    {
                                        HasTableResult = true,
                                    };
                                    break;
                                }
                                if (info == null)
                                {
                                    continue;
                                }
                                info.ObjectId       = id;
                                info.CreateDate     = create;
                                info.ModifyDate     = modify;
                                programmables[name] = info;
                                info.FullName       = name;
                                if (objs.ContainsKey(name))
                                {
                                    info.CreateSql = objs[name];
                                }
                                if (info is StoredProcedureInfo)
                                {
                                    Structure.StoredProcedures.Add((StoredProcedureInfo)info);
                                }
                                if (info is FunctionInfo)
                                {
                                    Structure.Functions.Add((FunctionInfo)info);
                                }
                            }
                        }
                    }

                    Timer("parameters...");

                    try
                    {
                        // load parameters
                        using (var cmd = Connection.CreateCommand())
                        {
                            cmd.CommandText = CreateQuery("parameters.sql", procedures: true, functions: true);
                            using (var reader = cmd.ExecuteReader())
                            {
                                while (reader.Read())
                                {
                                    var name = new NameWithSchema(reader.SafeString("SPECIFIC_SCHEMA"), reader.SafeString("SPECIFIC_NAME"));
                                    if (!programmables.ContainsKey(name))
                                    {
                                        continue;
                                    }
                                    var prg = programmables[name];
                                    if (reader.SafeString("IS_RESULT") == "YES")
                                    {
                                        var func = prg as FunctionInfo;
                                        if (func == null)
                                        {
                                            continue;
                                        }
                                        func.ResultType = reader.SafeString("DATA_TYPE");
                                        continue;
                                    }
                                    var arg = new ParameterInfo(prg);
                                    prg.Parameters.Add(arg);
                                    arg.DataType = reader.SafeString("DATA_TYPE");
                                    arg.Name     = reader.SafeString("PARAMETER_NAME");
                                    arg.IsOutput = reader.SafeString("PARAMETER_MODE") == "OUT";
                                    int precision = reader.SafeString("NUMERIC_PRECISION").SafeIntParse();
                                    int scale     = reader.SafeString("NUMERIC_SCALE").SafeIntParse();
                                    int length    = reader.SafeString("CHARACTER_MAXIMUM_LENGTH").SafeIntParse();
                                    arg.CommonType = AnalyseType(arg.DataType, length, precision, scale);
                                }
                            }
                        }
                    }
                    catch (Exception err)
                    {
                        AddErrorReport("Error loading parameters", err);
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading programmables", err);
                }
            }

            Timer("view structure...");

            if (FilterOptions.AnyViews && IsViewsPhase)
            {
                try
                {
                    // load view structure
                    foreach (var view in Structure.Views)
                    {
                        if (FilterOptions.ViewFilter != null && !FilterOptions.ViewFilter.Contains(view.ObjectId))
                        {
                            continue;
                        }

                        using (var cmd = Connection.CreateCommand())
                        {
                            cmd.CommandText = SqlServerLinkedServer.ReplaceLinkedServer("SELECT * FROM [SERVER]." + dialect.QuoteFullName(view.FullName), LinkedServerName, DatabaseName);
                            try
                            {
                                using (var reader = cmd.ExecuteReader(CommandBehavior.SchemaOnly | CommandBehavior.KeyInfo))
                                {
                                    var queryInfo = reader.GetQueryResultInfo();
                                    view.QueryInfo = queryInfo;
                                }
                            }
                            catch (Exception err)
                            {
                                view.QueryInfo = null;
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading view structure", err);
                }
            }

            if (FilterOptions.GlobalSettings && IsSettingsPhase)
            {
                try
                {
                    Timer("default schema...");

                    // load default schema
                    using (var cmd = Connection.CreateCommand())
                    {
                        cmd.CommandText         = "SELECT SCHEMA_NAME()";
                        Structure.DefaultSchema = cmd.ExecuteScalar().ToString();
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading defgault schema", err);
                }
            }

            if (IsSettingsPhase)
            {
                try
                {
                    Timer("schemas...");

                    // load schemas
                    using (var cmd = Connection.CreateCommand())
                    {
                        Structure.Schemas.Clear();
                        cmd.CommandText = CreateQuery("getschemas.sql");
                        using (var reader = cmd.ExecuteReader())
                        {
                            while (reader.Read())
                            {
                                string name = reader.SafeString("name");
                                string id   = reader.SafeString("schema_id");
                                Structure.Schemas.Add(new SchemaInfo(Structure)
                                {
                                    ObjectId = id,
                                    Name     = name,
                                });
                            }
                        }
                    }
                }
                catch (Exception err)
                {
                    AddErrorReport("Error loading schemas", err);
                }
            }

            Timer("done...");

            //Structure.FixPrimaryKeys();
        }
Beispiel #51
0
 /// <summary>
 /// 初始化主键
 /// </summary>
 /// <param name="node">节点</param>
 /// <param name="table">所有者数据表</param>
 private void InitPrimaryKey(XmlNode node, TableInfo table)
 {
     table.PrimaryKeyRefCode = GetPrimaryKey(node);
 }
Beispiel #52
0
        public string WhereItems <TEntity>(TableInfo table, string aliasAndDot, IEnumerable <TEntity> items)
        {
            if (items == null || items.Any() == false)
            {
                return(null);
            }
            if (table.Primarys.Any() == false)
            {
                return(null);
            }
            var its = items.Where(a => a != null).ToArray();

            var pk1 = table.Primarys.FirstOrDefault();

            if (table.Primarys.Length == 1)
            {
                var sbin = new StringBuilder();
                sbin.Append(aliasAndDot).Append(this.QuoteSqlName(pk1.Attribute.Name));
                var indt = its.Select(a => pk1.GetMapValue(a)).Where(a => a != null).ToArray();
                if (indt.Any() == false)
                {
                    return(null);
                }
                if (indt.Length == 1)
                {
                    sbin.Append(" = ").Append(this.FormatSql("{0}", indt.First()));
                }
                else
                {
                    sbin.Append(" IN (").Append(string.Join(",", indt.Select(a => this.FormatSql("{0}", a)))).Append(")");
                }
                return(sbin.ToString());
            }
            var dicpk = its.Length > 5 ? new Dictionary <string, bool>() : null;
            var sb    = its.Length > 5 ? null : new StringBuilder();
            var iidx  = 0;

            foreach (var item in its)
            {
                var filter = "";
                foreach (var pk in table.Primarys)
                {
                    filter += $" AND {aliasAndDot}{this.QuoteSqlName(pk.Attribute.Name)} = {this.FormatSql("{0}", pk.GetMapValue(item))}";
                }
                if (string.IsNullOrEmpty(filter))
                {
                    continue;
                }
                if (sb != null)
                {
                    sb.Append(" OR (");
                    sb.Append(filter.Substring(5));
                    sb.Append(")");
                    ++iidx;
                }
                if (dicpk != null)
                {
                    filter = filter.Substring(5);
                    if (dicpk.ContainsKey(filter) == false)
                    {
                        dicpk.Add(filter, true);
                        ++iidx;
                    }
                }
                //++iidx;
            }
            if (iidx == 0)
            {
                return(null);
            }
            if (sb == null)
            {
                sb = new StringBuilder();
                foreach (var fil in dicpk)
                {
                    sb.Append(" OR (");
                    sb.Append(fil.Key);
                    sb.Append(")");
                }
            }
            return(iidx == 1 ? sb.Remove(0, 5).Remove(sb.Length - 1, 1).ToString() : sb.Remove(0, 4).ToString());
        }
Beispiel #53
0
 private void ConfigureTableInfoParameters(TableInfo tableInfo)
 {
     ParameterCollectionUI.ShowAsDialog(_activator, new ParameterCollectionUIOptionsFactory().Create(tableInfo));
 }
Beispiel #54
0
        public string WhereObject(TableInfo table, string aliasAndDot, object dywhere)
        {
            if (dywhere == null)
            {
                return("");
            }
            var type     = dywhere.GetType();
            var primarys = table.Primarys;
            var pk1      = primarys.FirstOrDefault();

            if (primarys.Length == 1 && (type == pk1.CsType || type.IsNumberType() && pk1.CsType.IsNumberType()))
            {
                return($"{aliasAndDot}{this.QuoteSqlName(pk1.Attribute.Name)} = {this.FormatSql("{0}", Utils.GetDataReaderValue(pk1.Attribute.MapType, dywhere))}");
            }
            else if (primarys.Length > 0 && (type == table.Type || type.BaseType == table.Type))
            {
                var sb    = new StringBuilder();
                var pkidx = 0;
                foreach (var pk in primarys)
                {
                    if (pkidx > 0)
                    {
                        sb.Append(" AND ");
                    }
                    sb.Append(aliasAndDot).Append(this.QuoteSqlName(pk.Attribute.Name));
                    sb.Append(this.FormatSql(" = {0}", pk.GetMapValue(dywhere)));
                    ++pkidx;
                }
                return(sb.ToString());
            }
            else if (dywhere is IEnumerable)
            {
                var sb    = new StringBuilder();
                var ie    = dywhere as IEnumerable;
                var ieidx = 0;
                foreach (var i in ie)
                {
                    var fw = WhereObject(table, aliasAndDot, i);
                    if (string.IsNullOrEmpty(fw))
                    {
                        continue;
                    }
                    if (ieidx > 0)
                    {
                        sb.Append(" OR ");
                    }
                    sb.Append(fw);
                    ++ieidx;
                }
                return(sb.ToString());
            }
            else
            {
                var sb    = new StringBuilder();
                var ps    = type.GetProperties();
                var psidx = 0;
                foreach (var p in ps)
                {
                    if (table.Columns.TryGetValue(p.Name, out var trycol) == false)
                    {
                        continue;
                    }
                    if (psidx > 0)
                    {
                        sb.Append(" AND ");
                    }
                    sb.Append(aliasAndDot).Append(this.QuoteSqlName(trycol.Attribute.Name));
                    sb.Append(this.FormatSql(" = {0}", Utils.GetDataReaderValue(trycol.Attribute.MapType, p.GetValue(dywhere))));
                    ++psidx;
                }
                if (psidx == 0)
                {
                    return("");
                }
                return(sb.ToString());
            }
        }
Beispiel #55
0
        internal string ExpressionLambdaToSql(Expression exp, List <SelectTableInfo> _tables, List <SelectColumnInfo> _selectColumnMap, Func <Expression[], string> getSelectGroupingMapString, SelectTableInfoType tbtype, bool isQuoteName)
        {
            if (exp == null)
            {
                return("");
            }
            switch (exp.NodeType)
            {
            case ExpressionType.Not: return($"not({ExpressionLambdaToSql((exp as UnaryExpression)?.Operand, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)})");

            case ExpressionType.Quote: return(ExpressionLambdaToSql((exp as UnaryExpression)?.Operand, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

            case ExpressionType.Lambda: return(ExpressionLambdaToSql((exp as LambdaExpression)?.Body, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

            case ExpressionType.Convert: return(ExpressionLambdaToSql((exp as UnaryExpression)?.Operand, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

            case ExpressionType.Negate:
            case ExpressionType.NegateChecked: return("-" + ExpressionLambdaToSql((exp as UnaryExpression)?.Operand, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

            case ExpressionType.Constant: return(_common.FormatSql("{0}", (exp as ConstantExpression)?.Value));

            case ExpressionType.Conditional:
                var condExp = exp as ConditionalExpression;
                return($"case when {ExpressionLambdaToSql(condExp.Test, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)} then {ExpressionLambdaToSql(condExp.IfTrue, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)} else {ExpressionLambdaToSql(condExp.IfFalse, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)} end");

            case ExpressionType.Call:
                var exp3     = exp as MethodCallExpression;
                var callType = exp3.Object?.Type ?? exp3.Method.DeclaringType;
                switch (callType.FullName)
                {
                case "System.String": return(ExpressionLambdaToSqlCallString(exp3, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

                case "System.Math": return(ExpressionLambdaToSqlCallMath(exp3, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

                case "System.DateTime": return(ExpressionLambdaToSqlCallDateTime(exp3, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

                case "System.TimeSpan": return(ExpressionLambdaToSqlCallTimeSpan(exp3, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));

                case "System.Convert": return(ExpressionLambdaToSqlCallConvert(exp3, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));
                }
                if (callType.FullName.StartsWith("FreeSql.ISelectGroupingAggregate`"))
                {
                    switch (exp3.Method.Name)
                    {
                    case "Count": return("count(1)");

                    case "Sum": return($"sum({ExpressionLambdaToSql(exp3.Arguments[0], _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)})");

                    case "Avg": return($"avg({ExpressionLambdaToSql(exp3.Arguments[0], _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)})");

                    case "Max": return($"max({ExpressionLambdaToSql(exp3.Arguments[0], _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)})");

                    case "Min": return($"min({ExpressionLambdaToSql(exp3.Arguments[0], _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)})");
                    }
                }
                if (callType.FullName.StartsWith("FreeSql.ISelect`"))            //子表查询
                {
                    if (exp3.Method.Name == "Any")                               //exists
                    {
                        var exp3Stack = new Stack <Expression>();
                        var exp3tmp   = exp3.Object;
                        while (exp3tmp != null)
                        {
                            exp3Stack.Push(exp3tmp);
                            switch (exp3tmp.NodeType)
                            {
                            case ExpressionType.Call: exp3tmp = (exp3tmp as MethodCallExpression).Object; continue;

                            case ExpressionType.MemberAccess: exp3tmp = (exp3tmp as MemberExpression).Expression; continue;
                            }
                            break;
                        }
                        object fsql = null;
                        List <SelectTableInfo> fsqltables = null;
                        var  fsqltable1SetAlias           = false;
                        Type fsqlType = null;
                        while (exp3Stack.Any())
                        {
                            exp3tmp = exp3Stack.Pop();
                            if (exp3tmp.Type.FullName.StartsWith("FreeSql.ISelect`") && fsql == null)
                            {
                                fsql     = Expression.Lambda(exp3tmp).Compile().DynamicInvoke();
                                fsqlType = fsql?.GetType();
                                if (fsqlType == null)
                                {
                                    break;
                                }
                                fsqlType.GetField("_limit", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(fsql, 1);
                                fsqltables = fsqlType.GetField("_tables", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(fsql) as List <SelectTableInfo>;
                                //fsqltables[0].Alias = $"{_tables[0].Alias}_{fsqltables[0].Alias}";
                                fsqltables.AddRange(_tables.Select(a => new SelectTableInfo {
                                    Alias = a.Type == SelectTableInfoType.Parent ? a.Alias : $"__parent_{a.Alias}_parent__",
                                    On    = "1=1",
                                    Table = a.Table,
                                    Type  = SelectTableInfoType.Parent
                                }));
                            }
                            else if (fsqlType != null)
                            {
                                var call3Exp = exp3tmp as MethodCallExpression;
                                var method   = fsqlType.GetMethod(call3Exp.Method.Name, call3Exp.Arguments.Select(a => a.Type).ToArray());
                                if (call3Exp.Method.ContainsGenericParameters)
                                {
                                    method.MakeGenericMethod(call3Exp.Method.GetGenericArguments());
                                }
                                var parms = method.GetParameters();
                                var args  = new object[call3Exp.Arguments.Count];
                                for (var a = 0; a < args.Length; a++)
                                {
                                    var argExp = (call3Exp.Arguments[a] as UnaryExpression)?.Operand;
                                    if (argExp != null && argExp.NodeType == ExpressionType.Lambda)
                                    {
                                        if (fsqltable1SetAlias == false)
                                        {
                                            fsqltables[0].Alias = (argExp as LambdaExpression).Parameters.First().Name;
                                            fsqltable1SetAlias  = true;
                                        }
                                    }
                                    args[a] = argExp;
                                    //if (args[a] == null) ExpressionLambdaToSql(call3Exp.Arguments[a], fsqltables, null, null, SelectTableInfoType.From, true);
                                }
                                method.Invoke(fsql, args);
                            }
                        }
                        if (fsql != null)
                        {
                            var sql = fsqlType.GetMethod("ToSql", new Type[] { typeof(string) })?.Invoke(fsql, new object[] { "1" })?.ToString();
                            if (string.IsNullOrEmpty(sql) == false)
                            {
                                foreach (var tb in _tables)
                                {
                                    sql = sql.Replace($"__parent_{tb.Alias}_parent__", tb.Alias);
                                }
                                return($"exists({sql})");
                            }
                        }
                    }
                }
                var other3Exp = ExpressionLambdaToSqlOther(exp3, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName);
                if (string.IsNullOrEmpty(other3Exp) == false)
                {
                    return(other3Exp);
                }
                throw new Exception($"未实现函数表达式 {exp3} 解析");

            case ExpressionType.MemberAccess:
                var exp4 = exp as MemberExpression;
                if (exp4.Expression != null && exp4.Expression.Type.IsArray == false && exp4.Expression.Type.IsNullableType())
                {
                    return(ExpressionLambdaToSql(exp4.Expression, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));
                }
                var extRet     = "";
                var memberType = exp4.Expression?.Type ?? exp4.Type;
                switch (memberType.FullName)
                {
                case "System.String": extRet = ExpressionLambdaToSqlMemberAccessString(exp4, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName); break;

                case "System.DateTime": extRet = ExpressionLambdaToSqlMemberAccessDateTime(exp4, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName); break;

                case "System.TimeSpan": extRet = ExpressionLambdaToSqlMemberAccessTimeSpan(exp4, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName); break;
                }
                if (string.IsNullOrEmpty(extRet) == false)
                {
                    return(extRet);
                }
                var other4Exp = ExpressionLambdaToSqlOther(exp4, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName);
                if (string.IsNullOrEmpty(other4Exp) == false)
                {
                    return(other4Exp);
                }

                var expStack = new Stack <Expression>();
                expStack.Push(exp);
                MethodCallExpression callExp = null;
                var exp2 = exp4.Expression;
                while (true)
                {
                    switch (exp2.NodeType)
                    {
                    case ExpressionType.Constant:
                        expStack.Push(exp2);
                        break;

                    case ExpressionType.Parameter:
                        expStack.Push(exp2);
                        break;

                    case ExpressionType.MemberAccess:
                        expStack.Push(exp2);
                        exp2 = (exp2 as MemberExpression).Expression;
                        if (exp2 == null)
                        {
                            break;
                        }
                        continue;

                    case ExpressionType.Call:
                        callExp = exp2 as MethodCallExpression;
                        expStack.Push(exp2);
                        exp2 = callExp.Object;
                        if (exp2 == null)
                        {
                            break;
                        }
                        continue;
                    }
                    break;
                }
                if (expStack.First().NodeType != ExpressionType.Parameter)
                {
                    return(_common.FormatSql("{0}", Expression.Lambda(exp).Compile().DynamicInvoke()));
                }
                if (callExp != null)
                {
                    return(ExpressionLambdaToSql(callExp, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName));
                }
                if (getSelectGroupingMapString != null && expStack.First().Type.FullName.StartsWith("FreeSql.ISelectGroupingAggregate`"))
                {
                    if (getSelectGroupingMapString != null)
                    {
                        var expText = getSelectGroupingMapString(expStack.Where((a, b) => b >= 2).ToArray());
                        if (string.IsNullOrEmpty(expText) == false)
                        {
                            return(expText);
                        }
                    }
                }

                if (_tables == null)
                {
                    var pp        = expStack.Pop() as ParameterExpression;
                    var memberExp = expStack.Pop() as MemberExpression;
                    var tb        = _common.GetTableByEntity(pp.Type);
                    if (tb.ColumnsByCs.ContainsKey(memberExp.Member.Name) == false)
                    {
                        throw new ArgumentException($"{tb.DbName} 找不到列 {memberExp.Member.Name}");
                    }
                    if (_selectColumnMap != null)
                    {
                        _selectColumnMap.Add(new SelectColumnInfo {
                            Table = null, Column = tb.ColumnsByCs[memberExp.Member.Name]
                        });
                    }
                    var name = tb.ColumnsByCs[memberExp.Member.Name].Attribute.Name;
                    if (isQuoteName)
                    {
                        name = _common.QuoteSqlName(name);
                    }
                    return(name);
                }
                Func <TableInfo, string, bool, SelectTableInfo> getOrAddTable = (tbtmp, alias, isa) => {
                    var finds = _tables.Where((a2, c2) => (isa || c2 > 0) && a2.Table.CsName == tbtmp.CsName).ToArray();                             //外部表,内部表一起查
                    if (finds.Length > 1)
                    {
                        finds = _tables.Where((a2, c2) => a2.Table.CsName == tbtmp.CsName && a2.Type == SelectTableInfoType.Parent && a2.Alias == $"__parent_{alias}_parent__").ToArray();                                 //查询外部表
                        if (finds.Any() == false)
                        {
                            finds = _tables.Where((a2, c2) => (isa || c2 > 0) && a2.Table.CsName == tbtmp.CsName && a2.Type != SelectTableInfoType.Parent).ToArray();                                     //查询内部表
                            if (finds.Length > 1)
                            {
                                finds = _tables.Where((a2, c2) => (isa || c2 > 0) && a2.Table.CsName == tbtmp.CsName && a2.Type != SelectTableInfoType.Parent && a2.Alias == alias).ToArray();
                            }
                        }
                    }
                    var find = finds.FirstOrDefault();
                    if (find == null)
                    {
                        _tables.Add(find = new SelectTableInfo {
                            Table = tbtmp, Alias = alias, On = null, Type = tbtype
                        });
                    }
                    return(find);
                };

                TableInfo       tb2 = null;
                string          alias2 = "", name2 = "";
                SelectTableInfo find2 = null;
                while (expStack.Count > 0)
                {
                    exp2 = expStack.Pop();
                    switch (exp2.NodeType)
                    {
                    case ExpressionType.Constant:
                        throw new NotImplementedException("未实现 MemberAccess 下的 Constant");

                    case ExpressionType.Parameter:
                    case ExpressionType.MemberAccess:

                        var exp2Type = exp2.Type;
                        if (exp2Type.FullName.StartsWith("FreeSql.ISelectGroupingAggregate`"))
                        {
                            exp2Type = exp2Type.GenericTypeArguments.FirstOrDefault() ?? exp2.Type;
                        }
                        var tb2tmp = _common.GetTableByEntity(exp2Type);
                        var mp2    = exp2 as MemberExpression;
                        if (mp2?.Member.Name == "Key" && mp2.Expression.Type.FullName.StartsWith("FreeSql.ISelectGroupingAggregate`"))
                        {
                            continue;
                        }
                        if (tb2tmp != null)
                        {
                            if (exp2.NodeType == ExpressionType.Parameter)
                            {
                                alias2 = (exp2 as ParameterExpression).Name;
                            }
                            else
                            {
                                alias2 = $"{alias2}__{mp2.Member.Name}";
                            }
                            find2  = getOrAddTable(tb2tmp, alias2, exp2.NodeType == ExpressionType.Parameter);
                            alias2 = find2.Alias;
                            tb2    = tb2tmp;
                        }
                        if (mp2 == null || expStack.Any())
                        {
                            continue;
                        }
                        if (tb2.ColumnsByCs.ContainsKey(mp2.Member.Name) == false)                                           //如果选的是对象,附加所有列
                        {
                            if (_selectColumnMap != null)
                            {
                                var tb3 = _common.GetTableByEntity(mp2.Type);
                                if (tb3 != null)
                                {
                                    var find3 = getOrAddTable(tb2tmp, $"{alias2}__{mp2.Member.Name}", exp2.NodeType == ExpressionType.Parameter);

                                    foreach (var tb3c in tb3.Columns.Values)
                                    {
                                        _selectColumnMap.Add(new SelectColumnInfo {
                                            Table = find3, Column = tb3c
                                        });
                                    }
                                    if (tb3.Columns.Any())
                                    {
                                        return("");
                                    }
                                }
                            }
                            throw new ArgumentException($"{tb2.DbName} 找不到列 {mp2.Member.Name}");
                        }
                        var col2 = tb2.ColumnsByCs[mp2.Member.Name];
                        if (_selectColumnMap != null && find2 != null)
                        {
                            _selectColumnMap.Add(new SelectColumnInfo {
                                Table = find2, Column = col2
                            });
                            return("");
                        }
                        name2 = tb2.ColumnsByCs[mp2.Member.Name].Attribute.Name;
                        break;

                    case ExpressionType.Call: break;
                    }
                }
                if (isQuoteName)
                {
                    name2 = _common.QuoteSqlName(name2);
                }
                return($"{alias2}.{name2}");
            }
            var expBinary = exp as BinaryExpression;

            if (expBinary == null)
            {
                var other99Exp = ExpressionLambdaToSqlOther(exp, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName);
                if (string.IsNullOrEmpty(other99Exp) == false)
                {
                    return(other99Exp);
                }
                return("");
            }
            if (expBinary.NodeType == ExpressionType.Coalesce)
            {
                return(_common.IsNull(
                           ExpressionLambdaToSql(expBinary.Left, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName),
                           ExpressionLambdaToSql(expBinary.Right, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName)));
            }
            if (dicExpressionOperator.TryGetValue(expBinary.NodeType, out var tryoper) == false)
            {
                return("");
            }
            var left  = ExpressionLambdaToSql(expBinary.Left, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName);
            var right = ExpressionLambdaToSql(expBinary.Right, _tables, _selectColumnMap, getSelectGroupingMapString, tbtype, isQuoteName);

            if (left == "NULL")
            {
                var tmp = right;
                right = left;
                left  = tmp;
            }
            if (right == "NULL")
            {
                tryoper = tryoper == "=" ? " IS " : " IS NOT ";
            }
            if (tryoper == "+" && (expBinary.Left.Type.FullName == "System.String" || expBinary.Right.Type.FullName == "System.String"))
            {
                return(_common.StringConcat(left, right, expBinary.Left.Type, expBinary.Right.Type));
            }
            if (tryoper == "%")
            {
                return(_common.Mod(left, right, expBinary.Left.Type, expBinary.Right.Type));
            }
            return($"{left} {tryoper} {right}");
        }
Beispiel #56
0
 public CdlFileStorage(TableInfo table)
 {
     _file  = Path.GetTempFileName();
     _cache = new FileStream(_file, FileMode.Create);
     _table = table;
 }
Beispiel #57
0
        public override KeyValuePair <string, TableInfo> UpdateTableInfo(string oldTableName, TableInfo oldTableInfo, List <string> contentTableNameList)
        {
            string newTableName = null;
            List <TableColumnInfo>      newColumns  = null;
            Dictionary <string, string> convertDict = null;

            if (StringUtils.ContainsIgnoreCase(contentTableNameList, oldTableName))
            {
                newTableName = oldTableName;
                newColumns   = TableContent.GetNewColumns(oldTableInfo.Columns);
                convertDict  = TableContent.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableAdministrator.OldTableName))
            {
                newTableName = TableAdministrator.NewTableName;
                newColumns   = TableAdministrator.NewColumns;
                convertDict  = TableAdministrator.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableAdministratorsInRoles.OldTableName))
            {
                newTableName = TableAdministratorsInRoles.NewTableName;
                newColumns   = TableAdministratorsInRoles.NewColumns;
                convertDict  = TableAdministratorsInRoles.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableArea.OldTableName))
            {
                newTableName = TableArea.NewTableName;
                newColumns   = TableArea.NewColumns;
                convertDict  = TableArea.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableChannel.OldTableName))
            {
                newTableName = TableChannel.NewTableName;
                newColumns   = TableChannel.NewColumns;
                convertDict  = TableChannel.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableChannelGroup.OldTableName))
            {
                newTableName = TableChannelGroup.NewTableName;
                newColumns   = TableChannelGroup.NewColumns;
                convertDict  = TableChannelGroup.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableConfig.OldTableName))
            {
                newTableName = TableConfig.NewTableName;
                newColumns   = TableConfig.NewColumns;
                convertDict  = TableConfig.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableContentCheck.OldTableName))
            {
                newTableName = TableContentCheck.NewTableName;
                newColumns   = TableContentCheck.NewColumns;
                convertDict  = TableContentCheck.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableContentGroup.OldTableName))
            {
                newTableName = TableContentGroup.NewTableName;
                newColumns   = TableContentGroup.NewColumns;
                convertDict  = TableContentGroup.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableCount.OldTableName))
            {
                newTableName = TableCount.NewTableName;
                newColumns   = TableCount.NewColumns;
                convertDict  = TableCount.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableDbCache.OldTableName))
            {
                newTableName = TableDbCache.NewTableName;
                newColumns   = TableDbCache.NewColumns;
                convertDict  = TableDbCache.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableDepartment.OldTableName))
            {
                newTableName = TableDepartment.NewTableName;
                newColumns   = TableDepartment.NewColumns;
                convertDict  = TableDepartment.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableErrorLog.OldTableName))
            {
                newTableName = TableErrorLog.NewTableName;
                newColumns   = TableErrorLog.NewColumns;
                convertDict  = TableErrorLog.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableKeyword.OldTableName))
            {
                newTableName = TableKeyword.NewTableName;
                newColumns   = TableKeyword.NewColumns;
                convertDict  = TableKeyword.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableLog.OldTableName))
            {
                newTableName = TableLog.NewTableName;
                newColumns   = TableLog.NewColumns;
                convertDict  = TableLog.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TablePermissionsInRoles.OldTableName))
            {
                newTableName = TablePermissionsInRoles.NewTableName;
                newColumns   = TablePermissionsInRoles.NewColumns;
                convertDict  = TablePermissionsInRoles.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableRelatedField.OldTableName))
            {
                newTableName = TableRelatedField.NewTableName;
                newColumns   = TableRelatedField.NewColumns;
                convertDict  = TableRelatedField.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableRelatedFieldItem.OldTableName))
            {
                newTableName = TableRelatedFieldItem.NewTableName;
                newColumns   = TableRelatedFieldItem.NewColumns;
                convertDict  = TableRelatedFieldItem.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableRole.OldTableName))
            {
                newTableName = TableRole.NewTableName;
                newColumns   = TableRole.NewColumns;
                convertDict  = TableRole.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableSite.OldTableName))
            {
                newTableName = TableSite.NewTableName;
                newColumns   = TableSite.NewColumns;
                convertDict  = TableSite.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableSiteLog.OldTableName))
            {
                newTableName = TableSiteLog.NewTableName;
                newColumns   = TableSiteLog.NewColumns;
                convertDict  = TableSiteLog.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableSitePermissions.OldTableName))
            {
                newTableName = TableSitePermissions.NewTableName;
                newColumns   = TableSitePermissions.NewColumns;
                convertDict  = TableSitePermissions.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTable.OldTableName))
            {
                newTableName = TableTable.NewTableName;
                newColumns   = TableTable.NewColumns;
                convertDict  = TableTable.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTableMatch.OldTableName))
            {
                newTableName = TableTableMatch.NewTableName;
                newColumns   = TableTableMatch.NewColumns;
                convertDict  = TableTableMatch.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTableMetadata.OldTableName))
            {
                newTableName = TableTableMetadata.NewTableName;
                newColumns   = TableTableMetadata.NewColumns;
                convertDict  = TableTableMetadata.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTableStyle.OldTableName))
            {
                newTableName = TableTableStyle.NewTableName;
                newColumns   = TableTableStyle.NewColumns;
                convertDict  = TableTableStyle.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTableStyleItem.OldTableName))
            {
                newTableName = TableTableStyleItem.NewTableName;
                newColumns   = TableTableStyleItem.NewColumns;
                convertDict  = TableTableStyleItem.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTag.OldTableName))
            {
                newTableName = TableTag.NewTableName;
                newColumns   = TableTag.NewColumns;
                convertDict  = TableTag.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTemplate.OldTableName))
            {
                newTableName = TableTemplate.NewTableName;
                newColumns   = TableTemplate.NewColumns;
                convertDict  = TableTemplate.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTemplateLog.OldTableName))
            {
                newTableName = TableTemplateLog.NewTableName;
                newColumns   = TableTemplateLog.NewColumns;
                convertDict  = TableTemplateLog.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableTemplateMatch.OldTableName))
            {
                newTableName = TableTemplateMatch.NewTableName;
                newColumns   = TableTemplateMatch.NewColumns;
                convertDict  = TableTemplateMatch.ConvertDict;
            }
            else if (StringUtils.EqualsIgnoreCase(oldTableName, TableUser.OldTableName))
            {
                newTableName = TableUser.NewTableName;
                newColumns   = TableUser.NewColumns;
                convertDict  = TableUser.ConvertDict;
            }

            return(GetNewTableInfo(oldTableName, oldTableInfo, newTableName, newColumns, convertDict));
        }
Beispiel #58
0
        private void SetupLowPrivilegeUserRightsFor(DiscoveredDatabase db, TestLowPrivilegePermissions permissions, TableInfo ti)
        {
            var dbType = db.Server.DatabaseType;

            //get access to the database using the current credentials
            var username = TestDatabaseSettings.GetLowPrivilegeUsername(dbType);
            var password = TestDatabaseSettings.GetLowPrivilegePassword(dbType);

            if (string.IsNullOrWhiteSpace(username) || string.IsNullOrWhiteSpace(password))
            {
                Assert.Inconclusive();
            }

            //give the user access to the table
            var sql = GrantAccessSql(username, dbType, permissions);

            using (var con = db.Server.GetConnection())
                UsefulStuff.ExecuteBatchNonQuery(sql, con);

            if (ti != null)
            {
                //remove any existing credentials
                foreach (DataAccessCredentials cred in CatalogueRepository.GetAllObjects <DataAccessCredentials>())
                {
                    CatalogueRepository.TableInfoCredentialsManager.BreakAllLinksBetween(cred, ti);
                }

                //set the new ones
                DataAccessCredentialsFactory credentialsFactory = new DataAccessCredentialsFactory(CatalogueRepository);
                credentialsFactory.Create(ti, username, password, DataAccessContext.Any);
            }
        }
        /// <inheritdoc/>
        public Dictionary <DataAccessContext, DataAccessCredentials> GetCredentialsIfExistsFor(TableInfo tableInfo)
        {
            var toReturn = new Dictionary <DataAccessContext, int>();

            using (var con = _repository.GetConnection())
            {
                var cmd = DatabaseCommandHelper.GetCommand("SELECT DataAccessCredentials_ID,Context FROM DataAccessCredentials_TableInfo WHERE TableInfo_ID = @tid", con.Connection, con.Transaction);
                cmd.Parameters.Add(DatabaseCommandHelper.GetParameter("@tid", cmd));
                cmd.Parameters["@tid"].Value = tableInfo.ID;

                var r = cmd.ExecuteReader();
                toReturn = GetLinksFromReader(r);
            }
            return(toReturn.ToDictionary(k => k.Key, v => _repository.GetObjectByID <DataAccessCredentials>(v.Value)));
        }
Beispiel #60
0
        void olvJoin_ButtonClick(object sender, CellClickEventArgs e)
        {
            var node = (AvailableForceJoinNode)e.Model;

            if (e.Column == olvJoinColumn)
            {
                //if it has Join Infos
                if (node.JoinInfos.Any())
                {
                    //Find all the joins columns
                    var cols = node.JoinInfos.Select(j => j.PrimaryKey).ToArray();

                    ColumnInfo toEmphasise = null;

                    //if there's only one column involved in the join
                    if (cols.Length == 1)
                    {
                        toEmphasise = cols[0]; //emphasise it to the user
                    }
                    else
                    {
                        //otherwise show all the columns and let them pick which one they want to navigate to (emphasise)
                        var dialog = new SelectDialog <IMapsDirectlyToDatabaseTable>(Activator, cols, false, false);

                        if (dialog.ShowDialog() == DialogResult.OK)
                        {
                            toEmphasise = (ColumnInfo)dialog.Selected;
                        }
                    }

                    if (toEmphasise != null)
                    {
                        Activator.RequestItemEmphasis(this, new EmphasiseRequest(toEmphasise, 1));
                    }

                    return;
                }

                var otherTables = olvJoin.Objects.OfType <AvailableForceJoinNode>().Where(n => !Equals(n, node)).Select(n => n.TableInfo).ToArray();

                if (otherTables.Length == 0)
                {
                    MessageBox.Show("There are no other tables so no join is required");
                    return;
                }

                TableInfo otherTable = null;
                if (otherTables.Length == 1)
                {
                    otherTable = otherTables[0];
                }
                else
                {
                    var dialog = new SelectDialog <IMapsDirectlyToDatabaseTable>(Activator, otherTables, false, false);
                    if (dialog.ShowDialog() == DialogResult.OK)
                    {
                        otherTable = (TableInfo)dialog.Selected;
                    }
                }

                if (otherTable != null)
                {
                    var cmd = new ExecuteCommandAddJoinInfo(Activator, node.TableInfo);
                    cmd.SetInitialJoinToTableInfo(otherTable);
                    cmd.Execute();
                }
            }
        }