在 Redshift 中的 WITH 变量中使用 LPAD 函数时出错

如何解决在 Redshift 中的 WITH 变量中使用 LPAD 函数时出错

你能告诉我为什么这会在 Redshift 中引发错误吗？

public class Model { }

public class Construction
{
    public Construction(Model model,MaterialVector materials)
    {
        SetLayers(materials);
    }

    internal void SetLayers(MaterialVector materials)
    {
    }
}

public interface ISourceOfData 
{
    public string Name { get; set; }
}

public interface IIdentity<T> 
{
    [Key]
    public Guid Id { get; set; }
}

public class IntendedSurfaceType { }

public class APIDbContext { }

public class KeyAttribute : Attribute { }

public class MaterialVector : Idisposable
{
    public void dispose()
    {
    }

    internal void Add(IMaterial p)
    {
    }
}

public interface IMaterialTypeResolver
{
    public IMaterialSource ResolveType(SourceData i);
}

public class MaterialTypeResolver : IMaterialTypeResolver
{
    public IMaterialSource ResolveType(SourceData sourceData)
    {
        //Problem here - I don't kNow how your ProjectUtils.EntityById works internally
        //So I'm guessing here that it uses a factory pattern

        //this method needs to return an IMaterialSource...
        //GlazingMaterialSource
        //AirGapMaterialSource
        //ect ect
        //for a given set of database values
        
        //essentially you need something coming from the database to tell the code
        //which type to create,we pass that the data base values
        //and it passes them later to the IMaterial in the AddToOsm call
        //so the IMaterial implementation can do whatever custom work
        return new OpaqueProjectMaterialSource(sourceData);
    }
}

public class ProjectUtils
{
    private IMaterialTypeResolver _MaterialTypeResolver;
    
    public ProjectUtils(IMaterialTypeResolver materialTypeResolver)
    {
        _MaterialTypeResolver = materialTypeResolver;
    }

    public T EntityById<T>(APIDbContext dbContext,Guid materialId) where T : new()
        //here you'd use the dbContext to populated this
        //though this one at a time stuff is pretty inefficient
        //it should be done as a single query if possible
        => new T();
        
    public IMaterialSource ResolvetoMaterialSource(SourceData i) => _MaterialTypeResolver.ResolveType(i);
}

public interface IMaterial
{
    public string Name { get; set;}
}

public abstract class MaterialBase : IMaterial 
{ 
    public string Name {get;set;}
    
    public MaterialBase(Model model,ISourceOfData source)
    {
        this.Name = source.Name;
    }   
}

public class AirGapMaterial : MaterialBase
{
    public AirGapMaterial(Model model,ISourceOfData source) : base(model,source)
    {    
    }
}

public class StandardGlazingMaterial : MaterialBase
{
    public StandardGlazingMaterial(Model model,source)
    {
    }
}

public class FenestrationMaterial : MaterialBase
{
    public FenestrationMaterial(Model model,source)
    {
    }
}

public class StandardOpaqueMaterial : OpaqueMaterial
{
    public StandardOpaqueMaterial(Model model,source)
    {
    }
}

public class OpaqueMaterial : MaterialBase
{
    public OpaqueMaterial(Model model,source)
    {
    }
}

public class SurfaceConstruction : IIdentity<Guid>
{
    [Key]
    public Guid Id { get; set; }
    
    private ProjectUtils _projectUtils;
    
    public SurfaceConstruction(ProjectUtils projectUtils)
    {
        _projectUtils = projectUtils;
    }

    public Construction AddToOsm(APIDbContext dbContext,Model model,IEnumerable<Guid> ids)
    {
        if(model is null) throw new ArgumentNullException(nameof(model));
        
        var materialSources = ids.Where(i => i != default)
            .Select(i => _projectUtils.EntityById<SourceData>(dbContext,i))
            .Select(i => _projectUtils.ResolvetoMaterialSource(i));

        using var materialVector = new MaterialVector();
        foreach (var materialSource in materialSources)
        {
            materialVector.Add(materialSource.AddToOsm(model));
        }
        return new Construction(model,materialVector);
    }
}

public interface IMaterialSource
{
    public IMaterial AddToOsm(Model model);
}

public class SourceData : ISourceOfData,IIdentity<Guid>
{
    [Key]
    public Guid Id { get; set; }
    public string Name { get; set; } = string.Empty;
    //add all the database loaded properties here
}

public abstract class MaterialSourceBase : IMaterialSource
{
    protected SourceData SourceData {get;set;}
    
    protected MaterialSourceBase(SourceData sourceData)
    {
        SourceData = sourceData;
    }
    
    public abstract IMaterial AddToOsm(Model model);
}

//So at this point you Could generalize all of this down to a single
//factory pattern backed function as all we care about are
//given a set of database values,give me an IMaterial
public class OpaqueProjectMaterialSource : MaterialSourceBase
{
    public OpaqueProjectMaterialSource(SourceData sourceData) : base(sourceData)
    {
    }
    
    public override IMaterial AddToOsm(Model model) => new StandardOpaqueMaterial(model,base.sourceData);
}

public class AirGapMaterialSource : MaterialSourceBase
{
    public AirGapMaterialSource(SourceData sourceData) : base(sourceData)
    {
    }
    
    public override IMaterial AddToOsm(Model model) => new AirGapMaterial(model,base.sourceData);
}

public class GlazingMaterialSource : MaterialSourceBase
{
    public GlazingMaterialSource(SourceData sourceData) : base(sourceData)
    {
    }
    
    public override IMaterial AddToOsm(Model model) => new StandardGlazingMaterial(model,base.sourceData);
}

这是我收到的错误：

“操作无效：找不到从“未知”到文本的转换函数；”

解决方法

Redshift 无法从上下文中确定数据类型，因此需要显式设置

WITH Testing_PADDING AS (SELECT '12345678'::text AS column1)
SELECT
    LPAD(column1,9,'0')
FROM Testing_PADDING;

,

我怀疑您的一个字符串没有被视为文本 - 可能是 column1 文本。 （抱歉没有集群不测试）

试试：

WITH Testing_PADDING AS (SELECT '12345678'::text AS column1)
SELECT LPAD(column1,'0'::text) FROM Testing_PADDING;