linqtolucene Release Rss Feed

Created Release: LinqToLucene v0.61 (Apr 02, 2012)

stemarie — Mon, 02 Apr 2012 13:49:59 GMT

Released: LinqToLucene v0.61 (Apr 02, 2012)

Mon, 02 Apr 2012 13:49:59 GMT

Updated Release: LinqToLucene v0.6 (Mar 26, 2012)

stemarie — Mon, 26 Mar 2012 21:04:04 GMT

Support for NoSQL Storage/Files
New StorageManager object, will manage entities in your own storage and index them as well
Azure Storage Support
- Azure Blobs
Completed
Incomplete
- Create Azure Blob Unit Tests
- Azure Table support

Released: LinqToLucene v0.6 (Mar 26, 2012)

Mon, 26 Mar 2012 21:04:04 GMT

Support for NoSQL Storage/Files
New StorageManager object, will manage entities in your own storage and index them as well
Azure Storage Support
- Azure Blobs
Completed
Incomplete
- Create Azure Blob Unit Tests
- Azure Table support

Updated Release: LinqToLucene v0.6 (Mar 26, 2012)

stemarie — Mon, 26 Mar 2012 20:59:51 GMT

Support for NoSQL Storage/Files
New StorageManager object, will manage entities in your own storage and index them as well
Azure Storage Support
- Azure Blobs
Completed
Incomplete
- 14877
- 14878

Updated Release: LinqToLucene v0.6 (Mar 26, 2012)

stemarie — Mon, 26 Mar 2012 20:47:21 GMT

Support for Text Files
New StorageManager object, will manage entities in your own storage and index them as well
Planning for Azure Storage Support
- Azure Blobs

Created Release: LinqToLucene v0.5 (Mar 24, 2012)

stemarie — Sun, 25 Mar 2012 13:07:58 GMT

Maintenance Release
Upgraded .NET Runtime to .NET 4
No API Changes

Released: LinqToLucene v0.5 (Mar 24, 2012)

Sun, 25 Mar 2012 13:07:58 GMT

Maintenance Release
Upgraded .NET Runtime to .NET 4
No API Changes

UPDATED RELEASE: 7. The Refactored Release (Jul 22, 2008)

Tue, 22 Jul 2008 12:45:51 GMT

This release includes a large set of changes to the library:

New API that mirrors LINQ to SQL Table<T>
IndexSet for managing a collection of indexes
DatabaseIndexSet for making indexes from a LINQ to SQL Data Context
Centralized document and field details readers
New LINQ methods: Count, Skip, Take, First, Last, ElementAt
Mapping attributes can be added to a separate type
IHit for providing Relevance and DocumentId to domain tier
Lucene.Net Directory agnostic Index<T>
Refactored ObjectTranslation - abstract an interface for swappable translators in the future
Added PagedList for paging hits
An extra demonstration project comparing LINQ to XML to LINQ to Lucene.Net
IndexContext is analogous to the ASP.NET HttpContext with exposed locking semantics
Alot more Unit Tests using MbUnit
Batch Indexing - still a work in progress

Released: 7. The Refactored Release (Jul 22, 2008)

Tue, 22 Jul 2008 12:45:51 GMT

This release includes a large set of changes to the library:

New API that mirrors LINQ to SQL Table<T>
IndexSet for managing a collection of indexes
DatabaseIndexSet for making indexes from a LINQ to SQL Data Context
Centralized document and field details readers
New LINQ methods: Count, Skip, Take, First, Last, ElementAt
Mapping attributes can be added to a separate type
IHit for providing Relevance and DocumentId to domain tier
Lucene.Net Directory agnostic Index<T>
Refactored ObjectTranslation - abstract an interface for swappable translators in the future
Added PagedList for paging hits
An extra demonstration project comparing LINQ to XML to LINQ to Lucene.Net
IndexContext is analogous to the ASP.NET HttpContext with exposed locking semantics
Alot more Unit Tests using MbUnit
Batch Indexing - still a work in progress

CREATED RELEASE: The Refactored Release (Jul 22, 2008)

Tue, 22 Jul 2008 12:45:14 GMT

This release includes a large set of changes to the library:

New API that mirrors LINQ to SQL Table<T>
IndexSet for managing a collection of indexes
DatabaseIndexSet for making indexes from a LINQ to SQL Data Context
Centralized document and field details readers
New LINQ methods: Count, Skip, Take, First, Last, ElementAt
Mapping attributes can be added to a separate type
IHit for providing Relevance and DocumentId to domain tier
Lucene.Net Directory agnostic Index<T>
Refactored ObjectTranslation - abstract an interface for swappable translators in the future
Added PagedList for paging hits
An extra demonstration project comparing LINQ to XML to LINQ to Lucene.Net
IndexContext is analogous to the ASP.NET HttpContext with exposed locking semantics
Alot more Unit Tests using MbUnit
Batch Indexing - still a work in progress

RELEASED: The Refactored Release (Jul 22, 2008)

Tue, 22 Jul 2008 12:45:14 GMT

This release includes a large set of changes to the library:

New API that mirrors LINQ to SQL Table<T>
IndexSet for managing a collection of indexes
DatabaseIndexSet for making indexes from a LINQ to SQL Data Context
Centralized document and field details readers
New LINQ methods: Count, Skip, Take, First, Last, ElementAt
Mapping attributes can be added to a separate type
IHit for providing Relevance and DocumentId to domain tier
Lucene.Net Directory agnostic Index<T>
Refactored ObjectTranslation - abstract an interface for swappable translators in the future
Added PagedList for paging hits
An extra demonstration project comparing LINQ to XML to LINQ to Lucene.Net
IndexContext is analogous to the ASP.NET HttpContext with exposed locking semantics
Alot more Unit Tests using MbUnit
Batch Indexing - still a work in progress

UPDATED RELEASE: 6. The Re-Release (Apr 29, 2008)

Tue, 29 Apr 2008 13:31:22 GMT

Its definitely been a long time since there has been a release and all I can do is apologize. Especially because there were somehow files missing during the previous release or in the source code. What is being pushed now has all of the latest changes zipped up and includes all of the projects, as well as the source code the version of Lucene this build uses. The solution file is called Lucene.Linq and is under the Lucene.Linq folder.

In general I'll be trying to work with one of the other developers on this project to get the complete source into the 'Source Code' branch via source control integration and this project should begin to become revived. Sorry for the delay, I hope this early set of code helps generate feedback to help guide and push this project toward 'completion', whatever that means.

UPDATED RELEASE: 5. The Type-Conversion Release (Nov 19, 2007)

Mon, 19 Nov 2007 18:00:41 GMT

*Types beyond just Strings are now supported!*
As promised (albeit out of order), support has been added for type-conversion. If the type of the indexed-property uses a type-converter that supports conversion from a string, the type will automatically convert to its appropriate type.

This automatically inlcudes string, bool, int, datetime and a number of other .net types that already implement their own type-converters. Custom types can implement their own type-converters. For more information on type-converters please review either of the following articles: Using:[url:Code Project|http://www.codeproject.com/useritems/Type_Converters.asp] or Creating:[url:MSDN|http://msdn2.microsoft.com/en-us/library/ayybcxe5.aspx]

UPDATED RELEASE: 4. The Query Release (Nov 13, 2007)

Tue, 13 Nov 2007 19:41:02 GMT

UPDATED RELEASE: 4. The Query Release (Nov 13, 2007)

Tue, 13 Nov 2007 19:02:33 GMT

UPDATED RELEASE: 4. The Query Release (Nov 13, 2007)

Tue, 13 Nov 2007 18:19:06 GMT

This release provides a real focus on the querying abilities of the _LINQ to Lucene_ project and is the first real 'working release', converting LINQ statements to Lucene queries with deferred query execution and object creation or projection. It culminates the majority of the required querying features for LINQ that Lucene provides natively.

*[Documentation|Project Documentation]*
New documentation has been provided to give a deeper understanding about the way _LINQ to Lucene_ works. This documentation provides samples of _LINQ to Lucene_ in action.

*Credit*
[url:The Wayward Weblog|http://blogs.msdn.com/mattwar/archive/2007/07/30/linq-building-an-iqueryable-provider-part-i.aspx]
Again, credit must be given to Matt Warren of the Wayward Weblog who provided the building blocks used by _LINQ to Lucene_ with regards to the Expression Tree Evaluation and projection. For a deeper understanding of how this project was implemented, it is reccomended that you spend time with the LINQ series he provides. Thank you Matt.

UPDATED RELEASE: 3. The Operator Release (Nov 06, 2007)

Tue, 13 Nov 2007 18:18:51 GMT

Support has been added for multiple operators. It supports querying both directly upon the {{Query<T>}} type and from within a {{Where()}} clause. Currently, the API looks within the {{Query<T>}} member's {{FieldAttribute}}s for any fields marked {{IsDefault=true}} to create the default field list. Some of the query operators listed below support specifying an explicit field for the queryString by using the {{Where()}} clause. Other operators will soon work within {{Where()}}, all will add support for specific fields when querying directly against {{Query<T>}}.

*The operators that have been developed include the following:* with various overloads for each function _(not listed here)_
|{{public static Query<T> Search<T>(string queryString)}}|_Applies native Lucene syntax_|
|{{public static Query<T> Boost<T>(float factor)}}|_Boosts a search phrase_|
|{{public static Query<T> Like<T>(string phrase, float fuzziness)}}|_Applies Fuzzy or Proximity to a search_|
|{{public static Query<T> Match<T>(string phrase)}}|_Applies wildcard matches to search_|
|{{public static Query<T> StartsWith<T>(string phrase)}}|_Finds matches to the prefix of a phrase_|
|{{public static Query<T> Range<T>(string startRange, string endRange)}}|_Finds matches within the a range, inclusive by default_|
|{{public static Query<T> Between<T>(string from, string to)}}|_Finds matches within a range, exclusive_|
|{{public static Query<T> StartGroup<T>()}}|_Begins a query Grouping_|
|{{public static Query<T> Group<T>(Func<Query<T>, Query<T>> function)}}|_Performs a search function within a group_|
|{{public static Query<T> EndGroup<T>()}}|_Ends a query Grouping_|
|{{public static Query<T> Or<T>(Func<Query<T>, Query<T>> function)}}|_Applies OR logic to a set of conditions_|
|{{public static Query<T> And<T>(Func<Query<T>, Query<T>> function)}}|_Applies AND logic to a set of conditions_|

Code Samples:
{{
NorthwindIndexContext index = new NorthwindIndexContext();

var query = from c in index.Customers.Search("!myField:Jason test~); // Output: !myField:Jason test~

var query = from c in index.Customers.StartsWith("mar") // Output: mar*^2.3 OR asdf* (mo?se)
.Boost(2.3)
.Or(x => x.StartsWith("asdf")
.Group(x => x.Match("mo?se"));

var query = from c in index.Customers // Output: ContactName:"maria"~0.7
where c.ContactName.Like("maria", 0.7f)
select new { Name = c.ContactName, Id = c.CustomerID };
}}
NOTE:
This is in no way a 'stable' release but is a chance for developers to see some of the basics about how the API will work. There are certainly scenarios and types of queries that won't work or will produce unexpected results. Also, Xml commenting is still not anywhere near as thorough as it needs to be, nor is the exception handling and printing. These types of defects will be corrected in future builds.

Also, a lot of the operators currently only support using the default-fields of the type. Applying specific fields to an operation will be supported soon.

Also note that projection and object creation currently only supports translation to string types.

UPDATED RELEASE: 1. The Index Release (Oct 29, 2007)

Tue, 13 Nov 2007 18:18:34 GMT

*Project Source*
The project is structured to be a self-contained .dll called Lucene.Linq. The solution contains a project for the following:
-Lucene.Linq
-Lucene.Linq.Tests
-Lucene.Linq.Demo

Also, there are the mirror set of projects (upgraded to VS2K8) for the latest Lucene build:
(These are obviously not from our development but are there as a resource for debugging purposes)
-Lucene.Net
-Lucene.Net.Tests
-Lucene.Net.Demo

The Unit testing is provided by Visual Studios Test Project for the Lucene.Linq.Tests project, while the Lucene.Net.Tests project was built in an earlier version of NUnit.

*Dependencies:*
Lucene.Net 2.0 (Comes with the source)
NUnit (for Lucene.Net 2.0 project)
MS Enterprise Library 3.1 (Data, Common)
SQLExpress 2005 (for the Demo only)
Northwind Database (for the Demo only)

*Latest Upload*
The only portion of code that is currently up there is the ability to Write an Index from an 'Index Entity' class. At the moment, following the YAGNI approach, it makes a number of assumptions and it isn't 100% flexible yet but does a nice clean job of getting it's work done.

The key class is the IndexContext. The IndexContext class provides a constructor for adding both an index Directory and a Database. The only required parameter is the Directory which can be either a DirectoryInfo or a path. The Database can be either a ConnectionString name from web.config or an instance of a database. If the Database is not provided, the rest of the IndexContext class will work but the WriteIndex method will not be supported.

The IndexContext class will be implemented in much the same way that the DataContext class is written by the LINQ to SQL designer. With development scenarios likely inheriting directly from IndexContext and supporting properties and custom constructors for that implementation of the IndexContext class. There is an example in the Lucene.Linq.Demo project called NorthwindIndexContext.

To use the WriteIndex method, it assumes you have a class that is also a LINQ to SQL type class, with the {"[Table]"} and {"[Column]"} attributes. This certainly won't be a requirement to do any of the searching but in automatically writing an Index that maps to a database we make these assumptions about the class. The WriteIndex method evaluates the value of those attributes as well as the attributes of {"[Document]"} for the class and {"[Field]"} for the property.

The FieldAttribute class specifies the name of the field, the storage type, and the index type mapping to two enums that correspond to their Lucene.Net counterparts.
*FieldStore --> Field.Store
*FieldIndex --> Field.Index

The DocumentAttribute class provides information specific to creating an index from the class. The biggest current downfall of this attribute is that it currently only supports the StandardAnalayer class. Since we can not pass anything but contants, enums or types to an attribute, I currently am not sure of the best way for a class to specify the appropriate analyzer. I'm also not sure that the analyzer can even be inferred as globally as the class level, so some thoughts here are welcome.

The Demo project should create Write an Index for you based on the at the specified directory location listed in the app.config file.

UPDATED RELEASE: 2. The Conditional Release (Oct 31, 2007)

Tue, 13 Nov 2007 18:18:14 GMT

The latest release now supports a simple {{Where()}} clause in the statement.

*What it does*
* Single perdicate in the {{Where()}} statement, which means multiple field comparisons are not yet support with {{AND|OR}} clauses.
* The only operator supported is the {{Equals()}} or {{==}} operator
* Object Creation or Projection using Type conversion. Currently only supports String types.
Code Sample
{{
NorthwindIndexContext nw = new NorthwindIndexContext();
string name = "Maria";

var query = from c in context.Customers
where (c.ContactName == name)
select new { Name = c.CompanyName, Id = c.CustomerID };

ObjectDumper.Write(query);
}}

Support for Additional operators and predicates will be made available in upcoming releases.

*Acknowldegments*
The majority of the effort requires acknowledgement from the {url:Wayward Weblog|http://blogs.msdn.com/mattwar/archive/2007/07/30/linq-building-an-iqueryable-provider-part-i.aspx] by Matt Warren of Microsoft. Much of the Expression evaluation has used this as a starting point and been converted to code that supports the Lucene API.

As part of the porting process, this particular release is not fully unit-tested and may be a bit buggy along with the fact that many facets are still not yet supported. As a result the source code version is not yet available as additional pieces get stripped from or added to the code-base. Xml Commenting is also required. This release is made available to get any interested developers a small sense of how it will be like when working with the _LINQ to Lucene_ API.