public IEnumerable <KeyValuePair <string, string> > Execute()
        {
            log.Info(string.Format("Indexed scan operation for '{0}', filter: '{1}' {2} '{3}'.", tableName, filter.Column,
                                   OperatorConverter.ToComboString(filter.Operator).ToString(), filter.Value));

            switch (filter.Operator)
            {
            case Operator.Equal:
                var keys = index.Get(filter.Value);

                foreach (var key in keys)
                {
                    yield return(new KeyValuePair <string, string>(key, repository.Get(databaseFile, table.Name, key)));
                }
                break;

            case Operator.NotEqual:
                foreach (var row in GetNotEqual())
                {
                    yield return(row);
                }
                break;

            case Operator.Less:
                foreach (var row in GetLess())
                {
                    yield return(row);
                }
                break;

            case Operator.LessOrEqual:
                foreach (var row in GetLessOrEqual())
                {
                    yield return(row);
                }
                break;

            case Operator.Greater:
                foreach (var row in GetGreater())
                {
                    yield return(row);
                }
                break;

            case Operator.GreaterOrEqual:
                foreach (var row in GetGreaterOrEqual())
                {
                    yield return(row);
                }
                break;
            }
        }
Ejemplo n.º 2
0
        public IEnumerable <KeyValuePair <string, string> > Execute()
        {
            log.Info(string.Format("Filter operation for '{0}', filter: '{1}' {2} '{3}'.", filter.Table, filter.Column,
                                   OperatorConverter.ToComboString(filter.Operator).ToString(), filter.Value));

            // Determine where the filtered column is (is it part of the key, or is it part of the value).
            var primaryKey = KeyValue.Split(metadata.Key).ToArray();
            var columns    = KeyValue.Split(metadata.Value).ToArray();

            var filteredColumnInKey = primaryKey.Contains(filter.Column);
            int filteredColumnIndex = 0;

            if (filteredColumnInKey)
            {
                for (int i = 0; i < primaryKey.Count(); i++)
                {
                    if (filter.Column.Equals(primaryKey[i]))
                    {
                        filteredColumnIndex = i;
                        break;
                    }
                }
            }
            else
            {
                for (int i = 0; i < columns.Count(); i++)
                {
                    if (filter.Column.Equals(columns[i]))
                    {
                        filteredColumnIndex = i;
                        break;
                    }
                }
            }

            foreach (var row in Predecessor.Execute())
            {
                // Get the value of the column.
                var columnValue = string.Empty;

                if (filteredColumnInKey)
                {
                    columnValue = KeyValue.Split(row.Key).ToArray()[filteredColumnIndex];
                }
                else
                {
                    columnValue = KeyValue.Split(row.Value).ToArray()[filteredColumnIndex];
                }

                // Check if it satisfies the filter condition.
                int comparision = columnValue.CompareTo(filter.Value);

                switch (filter.Operator)
                {
                case Operator.Equal:
                    if (comparision == 0)
                    {
                        yield return(row);
                    }
                    break;

                case Operator.NotEqual:
                    if (comparision != 0)
                    {
                        yield return(row);
                    }
                    break;

                case Operator.Less:
                    if (comparision < 0)
                    {
                        yield return(row);
                    }
                    break;

                case Operator.Greater:
                    if (comparision > 0)
                    {
                        yield return(row);
                    }
                    break;

                case Operator.LessOrEqual:
                    if (comparision <= 0)
                    {
                        yield return(row);
                    }
                    break;

                case Operator.GreaterOrEqual:
                    if (comparision >= 0)
                    {
                        yield return(row);
                    }
                    break;
                }
            }
        }