github.com/prysmaticlabs/prysm@v1.4.4/beacon-chain/db/filters/filter.go (about)

     1  // Package filters specifies utilities for building a set of data attribute
     2  // filters to be used when filtering data through database queries in practice.
     3  // For example, one can specify a filter query for data by start epoch + end epoch + shard
     4  // for attestations, build a filter as follows, and respond to it accordingly:
     5  //
     6  //   f := filters.NewFilter().SetStartEpoch(3).SetEndEpoch(5)
     7  //   for k, v := range f.Filters() {
     8  //       switch k {
     9  //       case filters.StartEpoch:
    10  //          // Verify data matches filter criteria...
    11  //       case filters.EndEpoch:
    12  //          // Verify data matches filter criteria...
    13  //       }
    14  //   }
    15  package filters
    16  
    17  import types "github.com/prysmaticlabs/eth2-types"
    18  
    19  // FilterType defines an enum which is used as the keys in a map that tracks
    20  // set attribute filters for data as part of the `FilterQuery` struct type.
    21  type FilterType uint8
    22  
    23  const (
    24  	// ParentRoot defines a filter for parent roots of blocks using Simple Serialize (SSZ).
    25  	ParentRoot FilterType = iota
    26  	// StartSlot is used for range filters of objects by their slot (inclusive).
    27  	StartSlot
    28  	// EndSlot is used for range filters of objects by their slot (inclusive).
    29  	EndSlot
    30  	// StartEpoch is used for range filters of objects by their epoch (inclusive).
    31  	StartEpoch
    32  	// EndEpoch is used for range filters of objects by their epoch (inclusive).
    33  	EndEpoch
    34  	// HeadBlockRoot defines a filter for the head block root attribute of objects.
    35  	HeadBlockRoot
    36  	// SourceEpoch defines a filter for the source epoch attribute of objects.
    37  	SourceEpoch
    38  	// SourceRoot defines a filter for the source root attribute of objects.
    39  	SourceRoot
    40  	// TargetEpoch defines a filter for the target epoch attribute of objects.
    41  	TargetEpoch
    42  	// TargetRoot defines a filter for the target root attribute of objects.
    43  	TargetRoot
    44  	// SlotStep is used for range filters of objects by their slot in step increments.
    45  	SlotStep
    46  )
    47  
    48  // QueryFilter defines a generic interface for type-asserting
    49  // specific filters to use in querying DB objects.
    50  type QueryFilter struct {
    51  	queries map[FilterType]interface{}
    52  }
    53  
    54  // NewFilter instantiates a new QueryFilter type used to build filters for
    55  // certain Ethereum data types by attribute.
    56  func NewFilter() *QueryFilter {
    57  	return &QueryFilter{
    58  		queries: make(map[FilterType]interface{}),
    59  	}
    60  }
    61  
    62  // Filters returns and underlying map of FilterType to interface{}, giving us
    63  // a copy of the currently set filters which can then be iterated over and type
    64  // asserted for use anywhere.
    65  func (q *QueryFilter) Filters() map[FilterType]interface{} {
    66  	return q.queries
    67  }
    68  
    69  // SetParentRoot allows for filtering by the parent root data attribute of an object.
    70  func (q *QueryFilter) SetParentRoot(val []byte) *QueryFilter {
    71  	q.queries[ParentRoot] = val
    72  	return q
    73  }
    74  
    75  // SetHeadBlockRoot allows for filtering by the beacon block root data attribute of an object.
    76  func (q *QueryFilter) SetHeadBlockRoot(val []byte) *QueryFilter {
    77  	q.queries[HeadBlockRoot] = val
    78  	return q
    79  }
    80  
    81  // SetSourceRoot allows for filtering by the source root data attribute of an object.
    82  func (q *QueryFilter) SetSourceRoot(val []byte) *QueryFilter {
    83  	q.queries[SourceRoot] = val
    84  	return q
    85  }
    86  
    87  // SetTargetRoot allows for filtering by the target root data attribute of an object.
    88  func (q *QueryFilter) SetTargetRoot(val []byte) *QueryFilter {
    89  	q.queries[TargetRoot] = val
    90  	return q
    91  }
    92  
    93  // SetSourceEpoch enables filtering by the source epoch data attribute of an object.
    94  func (q *QueryFilter) SetSourceEpoch(val types.Epoch) *QueryFilter {
    95  	q.queries[SourceEpoch] = val
    96  	return q
    97  }
    98  
    99  // SetTargetEpoch enables filtering by the target epoch data attribute of an object.
   100  func (q *QueryFilter) SetTargetEpoch(val types.Epoch) *QueryFilter {
   101  	q.queries[TargetEpoch] = val
   102  	return q
   103  }
   104  
   105  // SetStartSlot enables filtering by all the items that begin at a slot (inclusive).
   106  func (q *QueryFilter) SetStartSlot(val types.Slot) *QueryFilter {
   107  	q.queries[StartSlot] = val
   108  	return q
   109  }
   110  
   111  // SetEndSlot enables filtering by all the items that end at a slot (inclusive).
   112  func (q *QueryFilter) SetEndSlot(val types.Slot) *QueryFilter {
   113  	q.queries[EndSlot] = val
   114  	return q
   115  }
   116  
   117  // SetStartEpoch enables filtering by the StartEpoch attribute of an object (inclusive).
   118  func (q *QueryFilter) SetStartEpoch(val types.Epoch) *QueryFilter {
   119  	q.queries[StartEpoch] = val
   120  	return q
   121  }
   122  
   123  // SetEndEpoch enables filtering by the EndEpoch attribute of an object (inclusive).
   124  func (q *QueryFilter) SetEndEpoch(val types.Epoch) *QueryFilter {
   125  	q.queries[EndEpoch] = val
   126  	return q
   127  }
   128  
   129  // SetSlotStep enables filtering by slot for every step interval. For example, a slot range query
   130  // for blocks from 0 to 9 with a step of 2 would return objects at slot 0, 2, 4, 6, 8.
   131  func (q *QueryFilter) SetSlotStep(val uint64) *QueryFilter {
   132  	q.queries[SlotStep] = val
   133  	return q
   134  }