Losowy wiersz z Linq do Sql

Kolejna próbka dla struktury encji:

var customers = db.Customers
                  .Where(c => c.IsActive)
                  .OrderBy(c => Guid.NewGuid())
                  .FirstOrDefault();

To nie działa z LINQ do SQL. OrderBy jest po prostu wyrzucany.

EDIT: dopiero co zauważyłem, że jest to LINQ do SQL, a nie LINQ do obiektów. Użyj kodu marca, żeby baza danych zrobiła to za Ciebie. Zostawiłam tę odpowiedź tutaj jako potencjalny punkt zainteresowania dla LINQ to Objects.

Możesz zachować ideę "bieżącej" wartości i bieżącej liczby. Po pobraniu kolejnej wartości, weź losową liczbę i zastąp " bieżący "na " nowy"z prawdopodobieństwem 1 / n, gdzie n jest liczbą.

Więc kiedy czytasz pierwszą wartość, zawsze tworzysz" bieżącą " wartość. Po odczytaniu drugiej wartości, Może sprawić, że bieżąca wartość (prawdopodobieństwo 1/2). Po odczytaniu trzeciej wartości, Może sprawić, że bieżąca wartość (prawdopodobieństwo 1/3) itd. Gdy zabraknie danych, aktualna wartość jest losowa ze wszystkich przeczytanych, z jednolitym prawdopodobieństwo.

Aby zastosować to z warunkiem, po prostu zignoruj wszystko, co nie spełnia warunku. Najprostszym sposobem na to jest rozważenie tylko sekwencji" dopasowania", od której należy zacząć, poprzez zastosowanie klauzuli Where.

Oto szybka realizacja. W porządku...

public static T RandomElement<T>(this IEnumerable<T> source,
                                 Random rng)
{
    T current = default(T);
    int count = 0;
    foreach (T element in source)
    {
        count++;
        if (rng.Next(count) == 0)
        {
            current = element;
        }            
    }
    if (count == 0)
    {
        throw new InvalidOperationException("Sequence was empty");
    }
    return current;
}

Jednym ze sposobów skutecznego osiągnięcia jest dodanie kolumny do danych Shuffle, która jest wypełniona losowo int(jak każdy rekord jest tworzony).

Częściowe Zapytanie o dostęp do tabeli w losowej kolejności to ...

Random random = new Random();
int seed = random.Next();
result = result.OrderBy(s => (~(s.Shuffle & seed)) & (s.Shuffle | seed)); // ^ seed);

To wykonuje operację XOR w bazie danych i rozkazuje przez Wyniki tego XOR.

Zalety: -

1. efektywny: SQL obsługuje zamawiania, nie trzeba pobierać całego tabela
2. powtarzalne: (dobre dla testowania) - można użyć tego samego losowe seed, aby wygenerować ten sam losowy zamówienie

To jest podejście używane przez mój system automatyki domowej do losowego losowania list odtwarzania. Każdego dnia wybiera nowe ziarno, dając spójną kolejność w ciągu dnia (umożliwiając łatwe wstrzymywanie / wznawianie), ale świeże spojrzenie na każdą playlistę każdego nowego dnia.

Jeśli chcesz uzyskać np. var count = 16 losowe wiersze z tabeli, możesz napisać

var rows = Table.OrderBy(t => Guid.NewGuid())
                        .Take(count);

Tutaj użyłem E. F, A Tabela to Dbset

Jeśli celem uzyskania losowych wierszy jest próbkowanie, rozmawiałem bardzo krótko tutaj o miłym podejściu od Larson et al., Microsoft Research team, gdzie opracowali Framework próbkowania dla SQL Server przy użyciu zmaterializowanych widoków. Jest też link do aktualnego artykułu.

Przyszedł tutaj zastanawiając się, jak uzyskać kilka losowych stron z niewielkiej liczby z nich, więc każdy użytkownik dostaje kilka różnych losowych stron 3.

To jest moje ostateczne rozwiązanie, praca z zapytaniem LINQ na liście stron w Sharepoint 2010. Jest w Visual Basicu, sorry: P

Dim Aleatorio As New Random()

Dim Paginas = From a As SPListItem In Sitio.RootWeb.Lists("Páginas") Order By Aleatorio.Next Take 3

Prawdopodobnie powinno się zrobić profilowanie przed zapytaniem o dużą liczbę wyników, ale jest to idealne dla mojego celu

List<string> lst = new List<string>();
lst.Add("Apple"); 
lst.Add("Guva");
lst.Add("Graps"); 
lst.Add("PineApple");
lst.Add("Orange"); 
lst.Add("Mango");

var customers = lst.OrderBy(c => Guid.NewGuid()).FirstOrDefault();

Wyjaśnienie: wstawiając guid (który jest losowy) kolejność z orderby byłaby losowa.

I have random function query against DataTables:

var result = (from result in dt.AsEnumerable()
              order by Guid.NewGuid()
              select result).Take(3); 

Poniższy przykład wywoła źródło, aby pobrać liczbę, a następnie zastosuje wyrażenie pomiń na źródle z liczbą od 0 do N. druga metoda zastosuje kolejność za pomocą obiektu losowego (który uporządkuje wszystko w pamięci) i wybierze liczbę przekazaną do wywołania metody.

public static class IEnumerable
{
    static Random rng = new Random((int)DateTime.Now.Ticks);

    public static T RandomElement<T>(this IEnumerable<T> source)
    {
        T current = default(T);
        int c = source.Count();
        int r = rng.Next(c);
        current = source.Skip(r).First();
        return current;
    }

    public static IEnumerable<T> RandomElements<T>(this IEnumerable<T> source, int number)
    {
        return source.OrderBy(r => rng.Next()).Take(number);
    }
}

Używam tej metody do pobierania losowych Newsów i jej działa dobrze;)

    public string LoadRandomNews(int maxNews)
    {
        string temp = "";

        using (var db = new DataClassesDataContext())
        {
            var newsCount = (from p in db.Tbl_DynamicContents
                             where p.TimeFoPublish.Value.Date <= DateTime.Now
                             select p).Count();
            int i;
            if (newsCount < maxNews)
                i = newsCount;
            else i = maxNews;
            var r = new Random();
            var lastNumber = new List<int>();
            for (; i > 0; i--)
            {
                int currentNumber = r.Next(0, newsCount);
                if (!lastNumber.Contains(currentNumber))
                { lastNumber.Add(currentNumber); }
                else
                {
                    while (true)
                    {
                        currentNumber = r.Next(0, newsCount);
                        if (!lastNumber.Contains(currentNumber))
                        {
                            lastNumber.Add(currentNumber);
                            break;
                        }
                    }
                }
                if (currentNumber == newsCount)
                    currentNumber--;
                var news = (from p in db.Tbl_DynamicContents
                            orderby p.ID descending
                            where p.TimeFoPublish.Value.Date <= DateTime.Now
                            select p).Skip(currentNumber).Take(1).Single();
                temp +=
                    string.Format("<div class=\"divRandomNews\"><img src=\"files/1364193007_news.png\" class=\"randomNewsImg\" />" +
                                  "<a class=\"randomNews\" href=\"News.aspx?id={0}\" target=\"_blank\">{1}</a></div>",
                                  news.ID, news.Title);
            }
        }
        return temp;
    }

Używanie LINQ do SQL w LINQPad jako instrukcji C# wygląda jak

IEnumerable<Customer> customers = this.ExecuteQuery<Customer>(@"SELECT top 10 * from [Customers] order by newid()");
customers.Dump();

Wygenerowany SQL to

SELECT top 10 * from [Customers] order by newid()

Jeśli używasz LINQPad, przełącz się na tryb C# program i zrób to w ten sposób:

void Main()
{
    YourTable.OrderBy(v => Random()).FirstOrDefault.Dump();
}

[Function(Name = "NEWID", IsComposable = true)]
public Guid Random()
{
    throw new NotImplementedException();
}

var cust = (from c in ctx.CUSTOMERs.ToList() select c).OrderBy(x => x.Guid.NewGuid()).Taket(2);

Wybierz losowy 2 wiersz

Aby dodać do rozwiązania marca Gravella. Jeśli nie pracujesz z samą klasą datacontext (ponieważ zastępujesz ją w jakiś sposób, np. aby sfałszować datacontext w celach testowych), nie możesz użyć zdefiniowanego UDF bezpośrednio: nie zostanie skompilowany do SQL, ponieważ nie używasz go w podklasie lub częściowej klasie rzeczywistej klasy kontekstu danych.

Obejściem tego problemu jest utworzenie funkcji Randomize w serwerze proxy, podając ją zapytaniem, które chcesz randomizowane:

public class DataContextProxy : IDataContext
{
    private readonly DataContext _context;

    public DataContextProxy(DataContext context)
    {
        _context = context;
    }

    // Snipped irrelevant code

    public IOrderedQueryable<T> Randomize<T>(IQueryable<T> query)
    {
        return query.OrderBy(x => _context.Random());
    }
}

Oto jak byś go użył w swoim kodzie:

var query = _dc.Repository<SomeEntity>();
query = _dc.Randomize(query);

Aby być kompletnym, oto jak zaimplementować to w FAKE datacontext (który używa w encjach pamięci):

public IOrderedQueryable<T> Randomize<T>(IQueryable<T> query)
{
    return query.OrderBy(x => Guid.NewGuid());
}