Version History

 Download Latest Version

Version 4.1

  • General: Added build for .NET Core 2.1 to take advantage of methods accepting Span<T> that are only available there.
  • SphinxQL/FluentAPI: SphinxConnector.NET now takes advantage of Span<T> and friends when reading results from searchd resulting in less memory allocations.
  • FluentAPI: Added overload to IFullTextQuery.Match() accepting ReadOnlyMemory<char>.
  • FluentAPI: Many operations involving building strings have been optimized to reduce allocations.
  • FluentAPI: Fixed a possible connection leak in IFulltextSession.BuildKeywords in case of an exception.

Version 4.0

  • General: .NET 4.5 is now the minimum required version when running on .NET Framework.
  • General: Added build for .NET Standard 2.0.
  • General: Sphinx 2.2.1 is now the minimum required version.
  • SphinxQL/FluentAPI: Added implementations of async methods.
  • SphinxQL/FluentAPI: A number of optimizations to reduce memory allocations and garbage collections.
  • SphinxQL/FluentAPI: Adapted version string parser to work with Manticore Search.
  • Fluent API: The JSON.NET library is no longer merged into the SphinxConnector.dll, it is now referenced via NuGet. This is a possible breaking change.
  • Fluent API: SphinxConnector.NET now uses the FastExpressionCompiler to compile expression trees which results in faster execution times and less memory allocations.
  • Fluent API: Added new method Metadata() to IFulltextQuery and removed overloads of ToList(), First() etc. that return query metadata. This is a breaking change.
  • Fluent API: Statement generation for Where() now emits braces as Manticore Search added support for using OR in WHERE. The number of generated braces can still be optimized, which will be done in a future version.
  • Fluent API: Added method Set to IFulltextQueryOptions which takes the option name as a string parameter, to allow newly added options to be used immediately.
  • Fluent API: Added overload to extension method GetSnippet which takes an instance of SnippetOptions as an argument.
  • Fluent API: Fixed cast not being emitted when accessing a numeric value in a dictionary within Select().

Version 3.12.7

  • General: Fixed exception during license validation when running under .NET Core 2.0 in compatibility mode.

Version 3.12.6

  • Fluent API: Fixed IList<T> not being recognized as a JSON object during statement generation.
  • SphinxQL/Fluent API: Fixed a performance issue during parameter look up if the collection contains a large number of parameters.

Version 3.12.4

  • Fluent API: Fixed incorrect statement generation for IFulltextSession.GetSuggestions() when using non-default options.
  • Fluent API: Added property RejectQueueLength to SuggestionOptions.
  • General: Fixed license key not being recognized when running within SQL Server.
  • General: Some minor optimizations.

Version 3.12.0

  • Fluent API: Added method GetSuggestions() to IFulltextSession (requires Sphinx 2.3.2).
  • Fluent API: Fixed strings in Select() not always being wrapped in a parameter where appropriate.
  • SphinxQL/Fluent API: Fixed a regression introduced in the last release while parsing Sphinx version strings of id32 builds (IndexOutOfRangeException).
  • General: Optimized memory allocations during logging.
  • General: SphinxHelper.EscapeString now escapes MAYBE.

Version 3.11.0

  • Fluent API: When accessing nested JSON objects, the path was not correctly resolved.
  • Fluent API: Any/All/Contains could not be used with a the value of a Dictionary entry, because the required cast to the appropriate collection type wasn't handled correctly.
  • Fluent API: Added public method Get() to ConnectionStringConfigurator which returns the configured connection string, as it might be useful for logging/debugging purposes.
  • Fluent API: Added support for PACKEDFACTORS().
  • Fluent API: When using In() in Select() with a string argument, the string wasn't wrapped in a parameter during translation to SphinxQL.
  • General: Added ReSharper annotations.
  • SphinxQL/FluentAPI: Updated the Sphinx version string parser, now that Sphinx has moved to Git. Before, the Sphinx version string would contain the SVN revision, which SphinxConnector.NET used (in addition to the version) to determine Sphinx capabilities (and certain quirks). Starting from 2.2.10, only the version will be used, previous versions build with the SVN revision will be treated as before, i.e. the SVN revision will be taken into account.

Version 3.10.7

  • SphinxQL/Fluent API: Fixed a possible hang when executing an UPDATE or DELETE statement that affects more than 251 documents.

Version 3.10.6

  • Fluent API: Fixed projection into a concrete type that contains the document as a property.
  • Fluent API: Fixed In() extension method from ObjectExtensions not being recognized when used in Select().
  • SphinxQL/Fluent API: Fixed EndOfStreamException when opening a connection to Sphinx 2.2.5 in case Sphinx doesn't accept any more connections (small protocol change as of Sphinx 2.2.5).

Version 3.10.3

  • Fluent API: Added support for using arbitrary attribute types with IN().
  • Fluent API: Added support for option rand_seed (Sphinx 2.2.4).

Version 3.10.1

  • Fluent API: Braces were not emitted in some cases when using conditions in Select().

Version 3.10.0

  • Fluent API: Added method QueryMulti() to ISphinxQLExecutor.
  • Fluent API: Added support for projecting results into dynamic objects with ISphinxQLExecutor (.NET 4.0 and higher).
  • Fluent API: Added support for using In() with string attributes.
  • Fluent API: Added support for Math.Atan2() (Sphinx 2.2.4).
  • Fluent API: Dynamically generated expressions weren't handled correctly with projection methods.

Version 3.9.1

  • SphinxQL/Fluent API: Account for change in network protocol as of Sphinx 2.2.3 (r4629).

Version 3.9.0

  • Fluent API: Added support for (method) call expressions to Select().
  • Fluent API: Where() now handles InvocationExpressions correctly.
  • Fluent API: Added functions MinTopWeight (MIN_TOP_WEIGHT()) and MinTopSortValue (MIN_TOP_SORTVAL()).
  • Fluent API: Fixed retrieval of prediction metadata with Sphinx 2.2.2-beta.
  • Fluent API: When deleting a document, the FulltextSessionContext reported the wrong operaton type (Query instead of Delete) while calling IFulltextStore.Conventions.GetIndexName().
  • Fluent API: Made constructor of ConventionConfiguration class public to allow for easier mocking of IFulltextStore.
  • Fluent API: Expression type was sometimes not set correctly for generic dictionaries (JSON attributes), which could cause exceptions in binary expressions.
  • General: SphinxHelper.EscapeString now also escapes '<'.
  • Native API: Added 2.1.4, 2.1.5, 2.1.6, and 2.2.2 to SphinxVersion class.

Version 3.8.1

  • Fluent API: Fixed error in statement generation for BuildSnippets (some options were wrongfully emitted as strings).

Version 3.8.0

  • Fluent API: Added support for HAVING (Sphinx 2.2.1).
  • Fluent API: Added support for LEAST and GREATEST to MVAs and JSON arrays via Min() and Max() methods (Sphinx 2.2.1).
  • Fluent API: Added support for IN, ALL, ANY, INDEXOF to JSON arrays (Sphinx 2.2.1).
  • Fluent API: Added support for array index access and null/not null comparisons for JSON objects (Sphinx 2.2.1).
  • Fluent API: Added support for new GEODIST() options (Sphinx 2.2.1).
  • Fluent API: Added support for LENGTH() to MVAs and JSON arrays via IEnumarable.Count(), ICollection.Count or Length (Sphinx 2.1.2).
  • Fluent API: Added support for BITDOT() function (Sphinx 2.1.2).
  • Fluent API: Added support for using user variables with In() and NotIn().
  • Fluent API: When sorting by a numeric JSON field, type conversion functions are automatically emitted with Sphinx 2.2.1, e.g. OrderBy(x => x.JSONObject.AnInt32) is translated to ORDER BY INTEGER(document.JSONObject.AnInt32).
  • Fluent API: Prediction counters returned from SHOW META have been renamed in Sphinx 2.2.1-beta, which means you can't use SphinxConnector.NET 3.8 with Sphinx 2.2 revisions prior to 4281 if you are using these counters. If you were using Sphinx 2.2.1 before the official beta release, you should update to the beta release. Also support for new counters has been added.
  • Natvie API: Added property for Sphinx 2.1.3 to SphinxVersion.

Version 3.7.0

  • Fluent API: Added DocumentNeedsIdAssigned and DocumentIdGenerator to IFulltextStore.Conventions.
  • Fluent API: Added support for passing options to GetSnippet() method (Sphinx 2.2.1)
  • Fluent API: When using JSON fields in aggregate functions such as SUM(), AVG(), etc. a type conversion function needs to be emitted for Sphinx to determine the correct type. Supported with Sphinx 2.1.2 and above.
  • Fluent API: Fixed bug where no braces were emitted for logical statements in SELECT-clauses.

Version 3.6.1

  • Fluent API: Fixed incorrect statement generation for options in case idf or tf_idf were used with another option.

Version 3.6.0

  • Fluent API: Added support for option max_predicted_time.
  • Fluent API: Added support for predicted values to metadata (Sphinx 2.2.1).
  • Fluent API: Added support for new tf_idf option (Sphinx 2.2.1).
  • Fluent API: Added support for function ZONESPANLIST().
  • Fluent API: Fixed regression: FlushChanges() failed to wrap internal exceptions in FulltextException.
  • SphinxQL/Fluent API: Protocol change to support selecting more than 250 columns/attributes (Sphinx 2.1.2).
  • Native API: Added support for tf_idf option to query flags (Sphinx 2.2.1).
  • Native API: Added support for filtering on JSON string attributes (Sphinx 2.2.1).

Version 3.5.0

  • Fluent API: Added support for subqueries (supported since 2.1.1).
  • Fluent API: DateTime properties which can be translated to a Sphinx equivalent (e.g. Month), can now be used directly with GroupBy().
  • Fluent API: Added support for n best group-by (Sphinx 2.2.1).
  • Fluent API: Arguments to Snippets() and Crc32() methods weren't properly escaped.
  • SphinxQL/Fluent API: Some optimizations to reduce memory usage and improve performance.
  • SphinxQL: SphinxQLDataReader.GetSchemaTable() should return null for non-select statements instead of throwing a NullReferenceException.
  • Native API: Added property for Sphinx 2.0.8 to SphinxVersion class.

Version 3.4.0

  • Fluent API: Added the ability to execute SphinxQL queries and have the results mapped to objects via IFulltextSession.Advanced.CreateSphinxQLExecutor (supported only with .NET 4).
  • Fluent API: Added support for grouping by multiple attributes (supported with Sphinx 2.1.2).
  • Fluent API: Projections into anonymous types now support using the document as a property and the creation of nested anonymous types.
  • SphinxQL: A sequence of strings can now be used as a parameter to statements.

Version 3.3.2

  • Fixed exception that occurred when invoking Where() more than two times in a query.
  • General: Fixed exception in .NET 4.0 build that occurred on machines that did not have .NET 4.5 installed. This was due to a faulty parameter to ILMerge during the build, which caused ILMerge to link against .NET 4.5 libraries.

Version 3.3.0

  • Fluent API: Added support for saving JSON attributes to real-time indexes.
  • Fluent API: Added support for new options 'boolean simplify', 'sort method', 'idf', and 'global_idf'.
  • Fluent API: Added string extension method GetSnippet(), which is translated to the new SphinxQL function SNIPPET().
  • Fluent API: Dictionaries in conjuction with JSON attributes can now be used in queries.
  • Fluent API: Added support for nullable types.
  • Fluent API: Made SerializeTypeAsJson in class ConventionConfiguration and JsonEntitySerializer in class Settings public.
  • Fluent API: Made classes JsonObjectSerializer and JsonValueConverter public.
  • Fluent API: During the retrieval of results, strings are automatically converted to an Enum if needed, even if SaveEnumsAsIntegers is true.
  • Fluent API: Arrays can now be used for MVA's.
  • SphinxQL: Implemented method GetChar() in SphinxQLDataReader.
  • SphinxQL: Automatic detection of System.Guid when used as parameter.
  • Native API: Added property QueryFlags to SphinxSearchOptions class.
  • Native API: Added support for sub-selects via method SetOuterSelect().

Version 3.2.0

  • Fluent API: Added support for enums. By default enums are persisted and retrieved as integers. This can be changed by setting ConventionConfiguration.SaveEnumsAsIntegers to false.
  • Fluent API: Added preliminary support for JSON attributes that are introduced with the upcoming Sphinx 2.1 release.
  • Fluent API: Added method BuildKeywords to IFulltextSession.
  • Fluent API: Added methods FirstFuture and FirstOrDefaultFuture to IFulltextQuery.
  • Fluent API: Added support for new Sphinx 2.1 functions EXIST() and GROUPBY()
  • Fluent API: Added new methods AttachIndex(), FlushIndex(), OptimizeIndex(), TruncateIndex(), CreateFunction(), and DropFunction(). They can be accessed via the 'Advanced' property of the IFulltextSession interface.
  • Fluent API: Added overloads to First and FirstOrDefault that return query metadata.
  • Fluent API: Added support for option 'ignore_nonexistent_indexes' (Sphinx 2.1).
  • Fluent API: Read-only fields and properties that don't have a setter aren't included in the column list for SELECT any more.
  • Fluent API: Fixed bug when using weight() in an expression and projecting results in a class that did not have a property for weight.
  • Fluent API/SphinxQL: Internal changes for compatibility with Sphinx 2.1.
  • Fluent API/SphinxQL: Several internal optimizations to reduce memory usage and improve performance.
  • SphinxQL: Fixed warning about unread results from SphinxQLDataReader being off by one in rare cases.
  • SphinxQL: Fixed a deadlock that occurred during the retrieval of the next result of a multi-query, if said query caused an error on the Sphinx side.
  • Native API: Added support for option to ignore non existent column to UpdateAttributes method (Sphinx 2.1).
  • Native API: Added property for Sphinx 2.0.7 to SphinxVersion class.

Version 3.1.4

  • Fluent API: The IFulltextSession interface accidentally exposed a method that was not ready for public use.

Version 3.1.3

  • Fluent API: Fixed a NullReferenceException that occured with certain queries.
  • SphixnQL: SphinxQLDataReader threw an exception if a result contained duplicate column names.
  • General: Fixed an exception during license validation when running in a medium trust environment.

Version 3.1.0

  • General: Added build for .NET 4.0
  • Fluent API: Added supprt for future queries. This feature allows to defer the execution of queries until their results are needed, enabling SphinxConnector.NET to send them in batches (supported only with .NET 4.0).
  • Fluent API: IFulltextQuery.Where can now be called multiple times for one query.
  • Fluent API: The generic type of collections for multi-value attributes e.g. IList<T> etc. can now be of any type that is large enough to hold the result values. Previously only 'long' was supported.
  • Fluent API: Added a workaround to the query generator to account for the fact that Sphinx currently doesn't support using 'weight()' in an expression, e.g. SELECT weight()*2 AS c1 FROM example. The query generator will now emit a separate, aliased weight() column and use the alias in the expression, e.g. SELECT weight() AS c2, c2*2 AS c1 FROM example.
  • SphixnQL: The RecordsAffected property of the SphinxQLDataReader class wasn't set correctly when the reader was used to read results from multiple SELECT or SHOW statements.
  • Native API: Added property for Sphinx 2.0.6 to SphinxVersion class.

Version 3.0.9

  • Fixed a possible race condition that occured when closing a connection with enabled connection pooling.

Version 3.0.8

  • Fluent API: Some characters in the match clause of a query were not send correctly to Sphinx.
  • Fluent API: Some options for the BuildSnippets method were send to Sphinx in the wrong case.

Version 3.0.6

  • Fixed a problem in the license validation code which could lead to valid licenses being rejected under certain conditions.
  • Improved message for exception that is thrown in case the value for a SphinxQLParameter is null.

Version 3.0.4

  • Added overload that takes a column name as parameter to method GetBoolean in SphinxQLDataReader.
  • Removed a stray letter in the output of the ToString method of SphinxWordInfo.
  • Fixed a possible exception when retrieving query meta data with the fluent API in trial mode.
  • Fixed an exception that occured when a connection, that was associated with an unclosed SphinxQLDataReader which was created with CommandBehavior.CloseConnection, was closed and returned to the connection pool.

Version 3.0.0

  • Introduced new fluent API.
  • General: Added experimental support for running under the Mono runtime (tested with Mono 2.10.x).
  • General: Upgraded Common.Logging to version 2, which adds support for recent releases of NLog, log4net etc.
  • General: SphinxConnector.NET can now be run in medium-trust environments (needs SocketPermission granted manually).
  • General: Fixed a bug when converting a .NET DateTime object to a Sphinx timestamp during daylight saving time.
  • SphinxQL: When logging the command text of a parameterized SphinxQLCommand, the values of each parameter are now logged after the command e.g. Executing command: INSERT INTO `foo` (id, title, content) VALUES (@p0, @p1, @p2) with @p0 = 1, @p1 = 'Title', @p2 = 'Content'
  • SphinxQL: To allow the use of user variables (e.g. in a SET statement), SphinxConnector.NET will not throw an exception any more if a parameter is not defined (because it could be a user variable).
  • SphinxQL: The SphinxQLParameter class now accepts IEnumerables that contain numeric values as a valid value for a parameter. The values from the enumerables will be treated as values for a multi-value attribute, i.e. they will be written to the statement as (x, y, z).
  • SphinxQL: The GetDecimal, GetDouble and GetValue methods of SphinxQLDataReader were missing an overload that takes a column name as parameter.
  • SphinxQL: Several small optimizations when executing SphinxQL statements.
  • SphinxQL: Calling the GetMvaValues method of the SphinxQLDataReader class when no values were present caused a FormatException to be thrown.
  • Native API: Added property for Sphinx version 2.0.5 to helper class SphinxVersion.
  • Native API: Removed method overloads by introducing optional parameters.

Breaking Changes:

  • The root namespace is now called 'SphinxConnector'.
  • The native API has been moved to its own namespace.
  • The License Property of the SphinxClient class has been removed. A new class SphinxConnectorLicensing with a SetLicense method has been added as a replacement.
  • Types that are used in more than one kind of API have been moved to the namespace named ‘Common’.
  • Removed all methods and properties that were marked a obsolete in 2.x.
  • Support for Sphinx versions < 2.0.1 has been dropped.

Version 2.8.4

  • SphinxQL: Fixed an exception that occured when a connection, that was associated with an unclosed SphinxQLDataReader which was created with CommandBehavior.CloseConnection, was closed and returned to the connection pool.
  • SphinxQL: Fixed a possible race condition that occured when closing a connection with enabled connection pooling.
  • SphinxQL: Calling the GetMvaValues method of the SphinxQLDataReader class when no values were present caused a FormatException to be thrown.
  • General: Fixed a bug when converting a .NET DateTime object to a Sphinx timestamp during daylight saving time.

Version 2.8.0

  • Native API: Added properties for Sphinx versions 2.0.3 and 2.0.4 to helper class SphinxVersion.
  • SphinxQL: The Sphinx revision number was not read correctly from pre-release builds, causing a System.FormatException on connection open.
  • SphinxQL: When closing a SphinxQLDataReader with multiple result sets pending, these result sets were not read from the underlying connection, before returning the connection to the pool. This made the connection unusable the next time it was returned from the pool, causing the connection to be discarded and a new connection to be opened.
  • SphinxQL: The command parser did not remove trailing semicolons from statements when executing against a Sphinx version > 2.0.x
  • SphinxQL: Log trace message when closing a SphinxQLDataReader.

Version 2.7.0

  • General: Added support for new features of Sphinx 2.0.2.
  • Native API: Added support for 64-bit MVAs with Sphinx 2.0.2.
  • Native API: Added support for the new expression based ranker introduced in Sphinx 2.0.2.

    Example:

    SphinxClient sphinxClient = new SphinxClient();
    sphinxClient.SearchOptions.MatchMode = SphinxMatchMode.Extended2; 
    sphinxClient.SearchOptions.RankMode = SphinxRankMode.Expression; 
    sphinxClient.SearchOptions.RankingExpression = sum((4*lcs+2*(min_hit_pos==1)+exact_hit)*user_weight)*1000+bm25;
    
  • Native API: Added support for new BuildExcerpts flag LoadFilesScattered.
  • Native API: Added a helper class SphinxVersion which contains System.Version properties for all supported Sphinx versions.

    Usage example:

    SphinxClient sphinxClient = new SphinxClient();
    sphinxClient.Version = SphinxVersion.V202;
  • SphinxQL: Some small internal fixes due to protocol changes in Sphinx 2.0.2.

Version 2.6.0

  • Native API: Added support for Sphinx 2.0.1. When using Sphinx 2.0.1, please assign new Version(2,0,1) to the Version property of the SphinxClient class.
  • Native API: Method QueryWithSphinxQL() has been marked as obsolete as it is no longer supported as of Sphinx v2.0.1.
  • SphinxQL: As of v2.0.1 Sphinx has server side support for multi-queries (SELECT and SHOW only). When using this version, SphinxConnector.NET's client side support for multi-queries will be automatically deactivated.
  • Added methods to convert from radians to degrees and vice versa to the SphinxHelper class.

Version 2.5.0

  • SphinxQL: The type used for representing signed and unsigned 64bit integers has been changed from System.Int64 to System.Decimal. This is to avoid potential integer overflows with very large 64bit document ids. Please note that this is a potentially breaking change, and you should check your code before deploying the new version to production. We're sorry for any inconvience this causes.

    This change does not break any calls to the GetXXX methods of the SphinxQLDataReader class except GetValue(), depending on how the result is used.

    It may break existing code in case a DataTable is used and column values are casted to their target types instead of being converted. The latter is also true if you use the GetField<T> extension methods introduced with .NET 3.5.

    Examples of method calls that will not break:

    long value = SphinxQLDataReader.GetInt64("my_big_int_column");
    long value = Convert.ToInt64(DataTable.Rows[0].Columns["my_big_int_column"]); 
    long value = Convert.ToInt64(SphinxQLDataReader.GetValue("my_big_int_column"));
    

    Examples of method calls that will break:

    long value = (long) SphinxQLDataReader.GetValue("my_big_int_column");
    Change to: long value = SphinxQLDataReader.GetInt64("my_big_int_column"); 
    or 
    decimal value = (decimal) SphinxQLDataReader.GetValue("my_big_int_column"); 
    or 
    long value = Convert.ToInt64(SphinxQLDataReader.GetValue("my_big_int_column");
    /*---------------------------------------------------------------------------*/
    long value = (long) DataTable.Rows[0].Columns["my_big_int_column"]; 
    and 
    long value = DataTable.Rows[0].GetValue<long>("my_big_int_column"); 
    Change to: 
    long value = Convert.ToInt64(DataTable.Rows[0].Columns["my_big_int_column"]); 
    or 
    decimal value = (decimal) DataTable.Rows[0].Columns["my_big_int_column"] 
    or 
    decimal value = DataTable.Rows[0].GetValue<decimal>("my_big_int_column");
    
  • SphinxQL: Added GetUInt64() method to SphinxQLDataReader.
  • SphinxQL: Added UBigInt to SphinxType enumeration.
  • Native API: The indexers of SphinxAttributeMatchCollection and SphinxStatusInfoCollection are now case-insentive.
  • The documentation can now be installed into the Visual Studio 2010 Help Library.
  • Small corrections to logging messages.
  • Small updates and corrections to the documentation.
  • The installer will now detect and automatically remove earlier versions.

Version 2.4.2

  • Fixed a performance regression in the native API, i.e. SphinxClient class, that caused a delay when opening a connection to Sphinx on a (remote) Windows server.

Version 2.4.1

  • Fixed exception that would be thrown, in case the NextResult method of the SphinxQLDataReader class was called without reading the complete current result first.

Version 2.4.0

  • Added RowUpdating and RowUpdated events to the SphinxQLDataAdapter class.
  • Implemented the GetSchema() method in the SphinxQLDataReader class.
  • Added support for the command type TableDirect.
  • Handling of OutOfMemoryException, StackOverflowException and ThreadAbortException in the SphinxQL implementation has been improved.
  • Support for using SphinxQLConnection, SphinxQLDataAdapter and SphinxQLCommand from the Visual Studio designer has been improved.
  • A bug in the handling of pooled connections which could cause connections to have an invalid state was fixed.
  • Exceptions that occured during a commit or rollback of a TransactionScope weren't logged correctly.
  • Committing or rolling back a transaction twice would throw a NullReferenceException instead of an InvalidOperationException.

Version 2.3.0

  • SphinxQL: New connection string option Encoding. This option sets the encoding that is used for both queries and result sets. The option Result Encoding is now obsolete.
    The default encoding is now utf-8. In previous version it defaulted to latin1 which could cause problems because most indexes are configured to use utf-8 as charset type. The reason the encoding has to be configured in the first place, is because Sphinx currently uses a hardcoded value of latin1 for the charset type of SphinxQL result packets.
  • SphinxQL: All GetXXX() methods of SphinxQLDataReader that take a column name as an argument are now case insensitive.
  • SphinxQL: Added property Code to SphinxQLException class which contains the error code returned by Sphinx.
  • SphinxQL: Creating a SphinxQLParameter object with a .NET type that has no equivalent Sphinx type would throw an exception, even if the Sphinx type to use was explicitly specified, e.g.
    double d = 5.0;
    var parameter = new SphinxQLParameter("name", d, SphinxType.Float);
    This is now fixed.
  • The behavior of SphinxQLParameterCollection.Add(object value) and Contains(object value) did not match other data providers:
    The given parameter was interpreted as the value, that the Value property of a SphinxQLParameter instance should be set to, i.e. Add() would a create new parameter object with the specified value, and Contains() would check the collection for a parameter with the specified value.
    This is the correct behavior according to the documentation of the base class, DbParameterCollection, but other data providers expect value to be an instance of the respective parameter class. Passing a value that is not a SphinxQLParameter, will not throw an exception, but trigger the old behavior and log a warning. This will be removed in a future release.
  • SphinxQL: SphinxQLConnectionStringBuilder was using the logger of the SphinxQLConnection class.
  • SphinxQL: The DbType property of SphinxQLParameter now supports DbType.Int32.
  • Some internal optimizations (SphinxQL and native API).

Version 2.2.0

  • Native API: Support for new build excerpts options introduced with Sphinx 1.10.1 Beta
  • SphinxQL: New connection string option ResultEncoding.
  • SphinxQL: Accessing the ServerVersion property of a closed SphinxQLConnection class would throw a NullReferenceException. Now an empty string is returned.
  • SphinxQL: The SphinxQLCommand class now supports the StoredProcedure command type. This can be used to call the SNIPPETS() AND KEYWORDS() functions.

Version 2.1.0

  • Added support for System.Transactions (TransactionScope)
  • New connection string option Enlist
  • Fixed a possible NullReferenceException in SphinxQLDataReader.Close()
  • The CommandTimeout property of the SphinxQLCommand class threw a NotSupportedException, which caused problems when the class was being used in the Visual Studio designer. Now the property can be assigned to, though it is still not supported.

Version 2.0.1

  • Changed sending of command type of queries to accommodate for changes in latest Sphinx trunk revision.
  • SphinxConnector.NET now detects automatically whether Sphinx supports the ping command.
  • Added property IsConnected to SphinxClient class.

Version 2.0.0

  • Full SphinxQL support
  • New logging and tracing infrastructure
  • An ArgumentOutOfRangeException was thrown in case Sphinx returned an empty result packet. Now a SphinxClientException with the message "Received zero-sized searchd response" is thrown.
  • The default port of the SphinxClient class has been changed to 9312.

Version 1.3.0

  • Optimizations in the network code which provide significant speed ups in conjunction with persistent connections (especially when Sphinx is not located on the same machine as the calling application).
  • Added support for querying Sphinx with SphinxQL. Introduced method QueryWithSphinxQL.
  • Added method SphinxHelper.EscapeString.
  • Query and AddQuery methods threw an ArgumentException if they received an empty ("") query string as input, although this is a valid query string.
  • Added property Encoding to SphinxClient class. If you are using sbcs encoding for one of your indexes, set this property to the appropriate encoding. Default is UTF8.
  • Setting the SphinxSearchOptions.SortBy property does not throw an InvalidOperationException anymore, if SphinxSearchOptions.SortMode is set to Relevance. The check has been moved to the query methods of the SphinxClient class.
  • Added support for Sphinx 1.10.1 (preliminary) and removed support for Sphinx 0.9.10 (replaced by 1.10.1).
  • Added QueryMode and ForceAllWords to BuildExcerptsOptions (introduced with Sphinx 1.10.1).
  • Added SphinxException class which all exceptions thrown by SphinxConnector.NET are now derived from.
  • Corrected some typos and wrong references in the documentation.

Version 1.2.0

  • SphinxSearchOptions.SetFilter() and SphinxSearchOptions.SetFilterRange() threw a NullReferenceException when passing IFilterableType or IRangeFilterableType instead of an implementing type as a parameter.
  • Property SphinxOrdinal.SphinxAttributeType of SphinxOrdinal did not return SphinxAttributeType.Ordinal.
  • Added method SphinxClient.ClearQueries() to SphinxClient class.
  • Implemented operators >= and <= in SphinxInteger, SphinxFloat, SphinxBigInt and SphinxTimestamp.
  • The ToString() methods of SphinxTimestamp, SphinxFloat and SphinxBigInt now return an appropriate string representation of the respective type.

Version 1.1.0

  • Support for string attributes introduced with Sphinx 0.9.10
  • Support for rank modes SPH04 and Total introduced with Sphinx 0.9.10
  • Added SphinxClient.FlushAttributes() method (needs Sphinx 0.9.10)
  • SphinxInteger can now be assigned to from System.Int32
  • SphinxAttributeMatch.ToString() now returns the attribute value(s)
  • A SphinxConversionException will now be thrown in case the conversion from a .NET type to a Sphinx type fails

Version 1.0.0

  • Initial release.