To validate or not?

Question

I am taking inputs from the user for which I am giving him choice.. For eg in column "conductor" he is given a choice "Al or Cu"

Similarly in column "insulator" he is given a choice "XLPE or PVC"

Now the above two are simple versions of lists I am giving to the user, but some of my lists depend on previous inputs and for that I am using datavalidation like this:

=indirect($C5 & "_" & $D5) 

(A named range for eg: al_xlpe)

Assuming column C and D refer to some inputs (This will lead to 2! named ranges being defined earlier).

Because of the above method I have been forced to use a lot of named ranges( some of my validation list choices depend on over 4 or more inputs, they go like this:

=indirect("col6" & "_" & col7 & "_" & col8 & "_" & col9) 

(another named range for eg: al_xlpe_duct_3;there can be 4! of these)

There are several problems I am facing:

1. Since databases can expand anytime for validation lists consisting of over 4 inputs will require 4! named range changes.
2. Data validation is easily lost(A major problem)
3. I cant restrict copy and paste since most of my users will be pasting data from other sheets(Cant use import since columns will never be fixed)
4. I cant use list boxes since any number of rows of data can be entered and i require choice in each row
5. Can't use MS Access for database management because my tool kind of works on input data and most of my users arent familiar with access(moreover it doesnt allow easy copy pasting of data)

Is there a better method?

Answer 1

In this answer, I offer a technique that was very popular when I started work as a programmer 45 years but which I have not seen used in a regular application by anyone but myself in many years. We had borrowed the technique from compiler development but used it much less formally.

In the full blown technique, there would be five steps:

1. Design a method of encoding the specification in a manner convenient for a human.
2. Encode the specification.
3. Design one or more tables to hold the specification in a manner convenient for fast processing.
4. Design and implement a program to convert the human format to the fast-processing format.
5. Design and implement a program to interpret the fast-processing format and perform the required operations.

Not all five steps were required for every problem; sometimes the human and fast-processing formats could be the same. This may sound complicated but it allowed us to solve many complex problems easily and efficiently.

In the worksheet below, I have encoded my understanding of the type of validation you require.

  |         A          |         B          |         C          |
--+--------------------+--------------------+--------------------+    
 1|Permitted           |Conditions -------------->               |
 2|C=V1|V2|V3|V4       |                    |                    |
 3|D=V5                |C=V1|V2             |                    |
 4|D=V6                |C=V3|V4             |                    |
 5|E=V7|V8             |D=V5                |C=V1                |
 6|E=V9|V10            |D=V5                |C=V2                |
 7|E=V11|V12           |D=V6                |C=V3                |
 8|E=V13|V14           |D=V6                |C=V4                |

In row 2, I declare that a cell in column C may take a value of V1 or V2 or V3 or V4.

In row 3, I declare that a cell in column D may take a value of V5 but only if column C of the same row has a value of V1 or V2.

In row 4, I declare an alternative value for a cell in column D with its own set of conditions.

In row 5, I declare that a cell in column E may take a value of V7 or V8 but only if column D of the same row has a value of V5 and column C of the row has a value of V1.

I do not have enough of an understanding of your requirement to know if this is the best or a complete representation of your validation requirements. However, I hope you get the idea and can develop a convenient representation of your requirement if you like this technique.

Next I need to define the fast-processing form of this specification. I have designed four tables and implemented the code below which converted the human worksheet format to the fast-processing format then output the contents of those tables to the immediate window ready to be placed in this answer:

Rules per Column table 
C RR RR                = Column   First rule   Last rule
3  1  1
4  2  3
5  4  7

There are three columns for which there are validation rules in the worksheet which are columns 3 (C), 4 (D) and 5 (E). The above table tells us that for column 3 (C), rules 1 to 1 apply and for column 5 (E), rules 4 to 7 apply.

Rule table              
I VV VV CC CC   = Index   First value   Last value   First condition   Last condition
1  1  4  1  0 
2  5  5  1  1 
3  8  8  2  2 
4 11 12  3  4 
5 15 16  5  6 
6 19 20  7  8 
7 23 24  9 10 

For Rule 1, conditions 1 to 0 apply, that is there are no conditions. The permitted values are entries 1 to 4 (V1, V2, V3 and V4) in the Value table. This corresponds to row 2 in the worksheet.

For Rule 4, the permitted values are entries 11 and 12 (V7 and V8) in the Value table providing conditions 3 to 4 apply. Condition 3 is that column 4 (D) must equal entry 13 (V5) in the Value table. Condition 4 is that column 3 (C) must equal entry 14 (V1) in the Value table. This corresponds to row 5 in the worksheet.

Condition table
 I C VV VV          = Index   Column   First value   Last value
 1 3  6  7
 2 3  9 10
 3 4 13 13
 4 3 14 14
 5 4 17 17
 6 3 18 18
 7 4 21 21
 8 3 22 22
 9 4 25 25
10 3 26 26

Value table                 Entries 1 to 26
E 1=V1  E 2=V2  E 3=V3  E 4=V4  E 5=V5  E 6=V1  E 7=V2  E 8=V6  E 9=V3  E10=V4   
E11=V7  E12=V8  E13=V5  E14=V1  E15=V9  E16=V10 E17=V5  E18=V2  E19=V11 E20=V12  
E21=V6  E22=V3  E23=V13 E24=V14 E25=V6  E26=V4

If you are not used to thinking about controlling code via linked tables, this may take a little time to understand fully. I have followed the links for a couple of rules. Try a few more and you will get the idea. Notice how the worksheet was designed to be easy for a human to mantain whereas these tables are designed for fast execution by a computer.

This compilation process could be within a Worksheet Open routine or you could pre-compile and store the tables in the workbook. These tables are ready for execution by a Worksheet Change routine or they could be used to calculate and place formulae in appropriate cells.

I hope I have explained this well enough for you to get the idea and to decide if this technique is appropriate for your problem. Could back with questions as necessary and I will expand the explanations.

The following code convert the human format to the fast processing format and then outputs the fast processing format to the immediate window.

Option Explicit

  Type typColRule      ' Definition of entry in Rules per Column table 
    InxRule1 As Long   ' Index of first rule for this column. ) InxRule1 > InxRuleL 
    InxRuleL As Long   ' Index of last rule for this column.  ) if no rules for column
  End Type
  Type typRule         ' Definition of Rule table 
    InxValue1 As Long  ' Index of first permitted value for this rule
    InxValueL As Long  ' Index of last permitted value for this rule
    InxCond1 As Long   ' Index of first condition for this column. ) InxCond1 > InxCondL 
    InxCondL As Long   ' Index of last rule for this column.       ) if no rules for column
  End Type
  Type typCond         ' Definition of Condition table
    Col As Long        ' Column to which this condition applies
    InxValue1 As Long  ' Index of first permitted value for this condition
    InxValueL As Long  ' Index of last permitted value for this condition
  End Type

  ' ColRule is sized to (Min to Max) where Min is the lowest column validated
  ' and Max is the highest column validated.  ColRule(N).InxRule1 identifies
  ' the first rule in Rule for column N.  ColRule(N).InsRuleL identifies the
  ' last rule in Rule for column N.
  Dim ColRule() As typColRule

  ' There is one entry in Rule per validation row in worksheet "Validate".
  Dim Rule() As typRule

  ' There is one entry in ValueCell per value referenced in a permitted or
  ' a condition.
  Dim ValueCell() As String

  ' There is one entry in Cond per condition in worksheet "Validate"
  Dim Cond() As typCond

Sub CompileValidation()

  Dim ColCodeCrnt As String
  Dim ColNumCrnt As String
  Dim ColValCrnt As Long
  Dim ColValidateCrnt As Long
  Dim ColValMin As Long
  Dim ColValMax As Long
  Dim ConditionCrnt As String
  Dim InxCondCrnt As Long
  Dim InxRuleCrnt As Long
  Dim InxValueCellCrnt As Long
  Dim InxValueListCrnt As Long
  Dim NumCond As Long
  Dim NumValue As Long
  Dim PermittedCrnt As String
  Dim PosEqual As Long
  Dim RowValidateCrnt As Long
  Dim ValueList() As String

  With Worksheets("Validate")

    ' Determine the size of the arrays to which information will be
    ' compiled.  Find
    '   * The minimum and maximum columns subject to validated
    '   * Number of conditions
    '   * Number of values references
    ' This routine does not allow for blank rows or columns in the
    ' middle of worksheet "Validate".
    ColValMin = -1
    ColValMax = -1
    NumCond = 0
    NumValue = 0
    RowValidateCrnt = 2
    Do While True
      PermittedCrnt = .Cells(RowValidateCrnt, 1).Value
      If PermittedCrnt = "" Then
        Exit Do
      End If
      PosEqual = InStr(1, PermittedCrnt, "=")
      Debug.Assert PosEqual > 1
      ' Determine range of columns validated
      ColCodeCrnt = Mid(PermittedCrnt, 1, PosEqual - 1)
      ColNumCrnt = Range(ColCodeCrnt & "1").Column
      If ColValMin = -1 Then
        ColValMin = ColNumCrnt
      ElseIf ColValMin > ColNumCrnt Then
        ColValMin = ColNumCrnt
      End If
      If ColValMax = -1 Then
        ColValMax = ColNumCrnt
      ElseIf ColValMax < ColNumCrnt Then
        ColValMax = ColNumCrnt
      End If
      ' Determine number of conditions and number of values
      ValueList = Split(Mid(PermittedCrnt, PosEqual + 1), "|")
      NumValue = NumValue + UBound(ValueList) - LBound(ValueList) + 1
      ColValidateCrnt = 2
      Do While True
        ConditionCrnt = .Cells(RowValidateCrnt, ColValidateCrnt).Value
        If ConditionCrnt = "" Then
          Exit Do
        End If
        PosEqual = InStr(1, ConditionCrnt, "=")
        Debug.Assert PosEqual > 1
        ValueList = Split(Mid(ConditionCrnt, PosEqual + 1), "|")
        NumValue = NumValue + UBound(ValueList) - LBound(ValueList) + 1
        ColValidateCrnt = ColValidateCrnt + 1
      Loop
      NumCond = NumCond + ColValidateCrnt - 2
      RowValidateCrnt = RowValidateCrnt + 1
    Loop

    ' Size arrays
    ReDim ColRule(ColValMin To ColValMax)
    ReDim Rule(1 To RowValidateCrnt - 2)
    ReDim ValueCell(1 To NumValue)
    ReDim Cond(1 To NumCond)

    InxRuleCrnt = 0
    InxValueCellCrnt = 0
    InxCondCrnt = 0

    ' Extract rules in column number order
    For ColValCrnt = ColValMin To ColValMax
      ' The first rule for this column, if any, will be the
      ' next entry in the Rule table
      ColRule(ColValCrnt).InxRule1 = InxRuleCrnt + 1
      ' If there are no rules for this column, the last rule index
      ' will be less than the first rule undex
      ColRule(ColValCrnt).InxRuleL = InxRuleCrnt
      RowValidateCrnt = 2
      Do While True
        PermittedCrnt = .Cells(RowValidateCrnt, 1).Value
        If PermittedCrnt = "" Then
          Exit Do
        End If
        PosEqual = InStr(1, PermittedCrnt, "=")
        ColCodeCrnt = Mid(PermittedCrnt, 1, PosEqual - 1)
        ColNumCrnt = Range(ColCodeCrnt & "1").Column
        If ColNumCrnt = ColValCrnt Then
          ' This rule is for the current column
          InxRuleCrnt = InxRuleCrnt + 1
          ' This could be the last rule for this column so
          ' store its index against the column
          ColRule(ColValCrnt).InxRuleL = InxRuleCrnt
          ' The first value for this rule will be the next
          ' entry in the Value table
          Rule(InxRuleCrnt).InxValue1 = InxValueCellCrnt + 1
          ValueList = Split(Mid(PermittedCrnt, PosEqual + 1), "|")
          ' Save each permitted value in the Value table
          For InxValueListCrnt = LBound(ValueList) To UBound(ValueList)
            InxValueCellCrnt = InxValueCellCrnt + 1
            ValueCell(InxValueCellCrnt) = ValueList(InxValueListCrnt)
          Next
          ' Record the index of the last permitted value for this rule
          Rule(InxRuleCrnt).InxValueL = InxValueCellCrnt
          ' The first condition for this rule, if any, will be the next
          ' entry in the Condition table
          Rule(InxRuleCrnt).InxCond1 = InxCondCrnt + 1
          ' If there are no conditions for this rule, the last condition
          ' index will be less than the first condition undex
          Rule(InxRuleCrnt).InxCondL = InxCondCrnt
          ColValidateCrnt = 2
          Do While True
            ConditionCrnt = .Cells(RowValidateCrnt, ColValidateCrnt).Value
            If ConditionCrnt = "" Then
              Exit Do
            End If
            InxCondCrnt = InxCondCrnt + 1
            PosEqual = InStr(1, ConditionCrnt, "=")
            ColCodeCrnt = Mid(ConditionCrnt, 1, PosEqual - 1)
            ColNumCrnt = Range(ColCodeCrnt & "1").Column
            ' Store the column for this condition
            Cond(InxCondCrnt).Col = ColNumCrnt
            ' The first value for this condition will be the next
            ' entry in the Value table
            Cond(InxCondCrnt).InxValue1 = InxValueCellCrnt + 1
            ValueList = Split(Mid(ConditionCrnt, PosEqual + 1), "|")
            For InxValueListCrnt = LBound(ValueList) To UBound(ValueList)
              InxValueCellCrnt = InxValueCellCrnt + 1
              ValueCell(InxValueCellCrnt) = ValueList(InxValueListCrnt)
            Next
            ' Record last value for this condition
            Cond(InxCondCrnt).InxValueL = InxValueCellCrnt
            ColValidateCrnt = ColValidateCrnt + 1
          Loop
          ' Record last condition for this rule
          Rule(InxRuleCrnt).InxCondL = InxCondCrnt
        End If
        RowValidateCrnt = RowValidateCrnt + 1
      Loop
    Next
  End With

  Debug.Print "    Rules per Column table"
  Debug.Print "    C RR RR"
  For ColValCrnt = ColValMin To ColValMax
    Debug.Print "    " & ColValCrnt & " " & _
                Right(" " & ColRule(ColValCrnt).InxRule1, 2) & " " & _
                Right(" " & ColRule(ColValCrnt).InxRuleL, 2)
  Next
  Debug.Print
  Debug.Print "    Rule table"
  Debug.Print "    I VV VV CC CC"
  For InxRuleCrnt = 1 To UBound(Rule)
    Debug.Print "    " & InxRuleCrnt & " " & _
                         Right(" " & Rule(InxRuleCrnt).InxValue1, 2) & " " & _
                         Right(" " & Rule(InxRuleCrnt).InxValueL, 2) & " " & _
                         Right(" " & Rule(InxRuleCrnt).InxCond1, 2) & " " & _
                         Right(" " & Rule(InxRuleCrnt).InxCondL, 2) & " "
  Next
  Debug.Print
  Debug.Print "    Condition table"
  Debug.Print "     I C VV VV"
  For InxCondCrnt = 1 To UBound(Cond)
    Debug.Print "    " & Right(" " & InxCondCrnt, 2) & " " & _
                         Cond(InxCondCrnt).Col & " " & _
                         Right(" " & Cond(InxCondCrnt).InxValue1, 2) & " " & _
                         Right(" " & Cond(InxCondCrnt).InxValueL, 2)
  Next
  Debug.Print
  Debug.Print "    Value table"
  Debug.Print "    ";
  For InxValueCellCrnt = 1 To UBound(ValueCell)
    Debug.Print "E" & Right(" " & InxValueCellCrnt, 2) & "=" & _
                Left(ValueCell(InxValueCellCrnt) & "    ", 5);
    If (InxValueCellCrnt Mod 10) = 0 Then
      Debug.Print
      Debug.Print "    ";
    End If
  Next

End Sub