Subversion Repositories Projects

<?xml version="1.0"?>

<doc>

    <assembly>

        <name>System.Data.SQLite.Linq</name>

    </assembly>

    <members>

        <member name="T:System.Data.SQLite.Linq.Properties.Resources">

            <summary>

              A strongly-typed resource class, for looking up localized strings, etc.

            </summary>

        </member>

        <member name="P:System.Data.SQLite.Linq.Properties.Resources.ResourceManager">

            <summary>

              Returns the cached ResourceManager instance used by this class.

            </summary>

        </member>

        <member name="P:System.Data.SQLite.Linq.Properties.Resources.Culture">

            <summary>

              Overrides the current thread's CurrentUICulture property for all

              resource lookups using this strongly typed resource class.

            </summary>

        </member>

        <member name="P:System.Data.SQLite.Linq.Properties.Resources.SQL_CONSTRAINTCOLUMNS">

             <summary>

               Looks up a localized string similar to CREATE TEMP VIEW SCHEMACONSTRAINTCOLUMNS AS

            SELECT CONSTRAINT_CATALOG, NULL AS CONSTRAINT_SCHEMA, CONSTRAINT_NAME, TABLE_CATALOG, NULL AS TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME

            FROM TEMP.SCHEMAINDEXCOLUMNS

            UNION

            SELECT CONSTRAINT_CATALOG, NULL, CONSTRAINT_NAME, TABLE_CATALOG, NULL, TABLE_NAME, FKEY_FROM_COLUMN

            FROM TEMP.SCHEMAFOREIGNKEYS;.

             </summary>

        </member>

        <member name="P:System.Data.SQLite.Linq.Properties.Resources.SQL_CONSTRAINTS">

             <summary>

               Looks up a localized string similar to CREATE TEMP VIEW SCHEMACONSTRAINTS AS

            SELECT INDEX_CATALOG AS CONSTRAINT_CATALOG, NULL AS CONSTRAINT_SCHEMA, INDEX_NAME AS CONSTRAINT_NAME, TABLE_CATALOG, NULL AS TABLE_SCHEMA, TABLE_NAME, 'PRIMARY KEY' AS CONSTRAINT_TYPE, 0 AS IS_DEFERRABLE, 0 AS INITIALLY_DEFERRED, NULL AS CHECK_CLAUSE

            FROM TEMP.SCHEMAINDEXES WHERE PRIMARY_KEY = 1

            UNION

            SELECT INDEX_CATALOG, NULL, INDEX_NAME, TABLE_CATALOG, NULL, TABLE_NAME, 'UNIQUE', 0, 0, NULL

            FROM TEMP.SCHEMAINDEXES WHERE PRIMARY_KEY = 0 AND [UNIQUE] = 1

            UNION

             [rest of string was truncated]";.

             </summary>

        </member>

        <member name="T:System.Data.SQLite.Linq.DmlSqlGenerator">

            <summary>

            Class generating SQL for a DML command tree.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.DmlSqlGenerator.IsIntegerPrimaryKey(System.Data.Metadata.Edm.EntitySetBase,System.Data.Metadata.Edm.ReadOnlyMetadataCollection{System.Data.Metadata.Edm.EdmMember}@,System.Data.Metadata.Edm.EdmMember@)">

            <summary>

            This method attempts to determine if the specified table has an integer

            primary key (i.e. "rowid").  If so, it sets the

            <paramref name="primaryKeyMember"/> parameter to the right

            <see cref="T:System.Data.Metadata.Edm.EdmMember"/>; otherwise, the

            <paramref name="primaryKeyMember"/> parameter is set to null.

            </summary>

            <param name="table">The table to check.</param>

            <param name="keyMembers">

            The collection of key members.  An attempt is always made to set this

            parameter to a valid value.

            </param>

            <param name="primaryKeyMember">

            The <see cref="T:System.Data.Metadata.Edm.EdmMember"/> that represents the integer primary key

            -OR- null if no such <see cref="T:System.Data.Metadata.Edm.EdmMember"/> exists.

            </param>

            <returns>

            Non-zero if the specified table has an integer primary key.

            </returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.DmlSqlGenerator.DoAllKeyMembersHaveValues(System.Data.SQLite.Linq.DmlSqlGenerator.ExpressionTranslator,System.Data.Metadata.Edm.ReadOnlyMetadataCollection{System.Data.Metadata.Edm.EdmMember},System.Data.Metadata.Edm.EdmMember@)">

            <summary>

            This method attempts to determine if all the specified key members have

            values available.

            </summary>

            <param name="translator">

            The <see cref="T:System.Data.SQLite.Linq.DmlSqlGenerator.ExpressionTranslator"/> to use.

            </param>

            <param name="keyMembers">

            The collection of key members to check.

            </param>

            <param name="missingKeyMember">

            The first missing key member that is found.  This is only set to a valid

            value if the method is returning false.

            </param>

            <returns>

            Non-zero if all key members have values; otherwise, zero.

            </returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.DmlSqlGenerator.GenerateReturningSql(System.Text.StringBuilder,System.Data.Common.CommandTrees.DbModificationCommandTree,System.Data.SQLite.Linq.DmlSqlGenerator.ExpressionTranslator,System.Data.Common.CommandTrees.DbExpression,System.Boolean)">

            <summary>

            Generates SQL fragment returning server-generated values.

            Requires: translator knows about member values so that we can figure out

            how to construct the key predicate.

            <code>

            Sample SQL:

                select IdentityValue

                from dbo.MyTable

                where @@ROWCOUNT > 0 and IdentityValue = scope_identity()

            or

                select TimestamptValue

                from dbo.MyTable

                where @@ROWCOUNT > 0 and Id = 1

            Note that we filter on rowcount to ensure no rows are returned if no rows were modified.

            </code>

            </summary>

            <param name="commandText">Builder containing command text</param>

            <param name="tree">Modification command tree</param>

            <param name="translator">Translator used to produce DML SQL statement

            for the tree</param>

            <param name="returning">Returning expression. If null, the method returns

            immediately without producing a SELECT statement.</param>

            <param name="wasInsert">

            Non-zero if this method is being called as part of processing an INSERT;

            otherwise (e.g. UPDATE), zero.

            </param>

        </member>

        <member name="T:System.Data.SQLite.Linq.DmlSqlGenerator.ExpressionTranslator">

            <summary>

            Lightweight expression translator for DML expression trees, which have constrained

            scope and support.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.DmlSqlGenerator.ExpressionTranslator.#ctor(System.Text.StringBuilder,System.Data.Common.CommandTrees.DbModificationCommandTree,System.Boolean,System.String)">

            <summary>

            Initialize a new expression translator populating the given string builder

            with command text. Command text builder and command tree must not be null.

            </summary>

            <param name="commandText">Command text with which to populate commands</param>

            <param name="commandTree">Command tree generating SQL</param>

            <param name="preserveMemberValues">Indicates whether the translator should preserve

            member values while compiling t-SQL (only needed for server generation)</param>

            <param name="kind"></param>

        </member>

        <member name="M:System.Data.SQLite.Linq.DmlSqlGenerator.ExpressionTranslator.RegisterMemberValue(System.Data.Common.CommandTrees.DbExpression,System.Data.Common.CommandTrees.DbExpression)">

            <summary>

            Call this method to register a property value pair so the translator "remembers"

            the values for members of the row being modified. These values can then be used

            to form a predicate for server-generation (based on the key of the row)

            </summary>

            <param name="propertyExpression">DbExpression containing the column reference (property expression).</param>

            <param name="value">DbExpression containing the value of the column.</param>

        </member>

        <member name="T:System.Data.SQLite.Linq.ISqlFragment">

            <summary>

            Represents the sql fragment for any node in the query tree.

            </summary>

            <remarks>

            The nodes in a query tree produce various kinds of sql

            <list type="bullet">

            <item>A select statement.</item>

            <item>A reference to an extent. (symbol)</item>

            <item>A raw string.</item>

            </list>

            We have this interface to allow for a common return type for the methods

            in the expression visitor <see cref="T:System.Data.Common.CommandTrees.DbExpressionVisitor`1"/>

            At the end of translation, the sql fragments are converted into real strings.

            </remarks>

        </member>

        <member name="M:System.Data.SQLite.Linq.ISqlFragment.WriteSql(System.Data.SQLite.Linq.SqlWriter,System.Data.SQLite.Linq.SqlGenerator)">

            <summary>

            Write the string represented by this fragment into the stream.

            </summary>

            <param name="writer">The stream that collects the strings.</param>

            <param name="sqlGenerator">Context information used for renaming.

            The global lists are used to generated new names without collisions.</param>

        </member>

        <member name="T:System.Data.SQLite.Linq.JoinSymbol">

            <summary>

            A Join symbol is a special kind of Symbol.

            It has to carry additional information

            <list type="bullet">

            <item>ColumnList for the list of columns in the select clause if this

            symbol represents a sql select statement.  This is set by <see cref="M:System.Data.SQLite.Linq.SqlGenerator.AddDefaultColumns(System.Data.SQLite.Linq.SqlSelectStatement)"/>. </item>

            <item>ExtentList is the list of extents in the select clause.</item>

            <item>FlattenedExtentList - if the Join has multiple extents flattened at the

            top level, we need this information to ensure that extent aliases are renamed

            correctly in <see cref="M:System.Data.SQLite.Linq.SqlSelectStatement.WriteSql(System.Data.SQLite.Linq.SqlWriter,System.Data.SQLite.Linq.SqlGenerator)"/></item>

            <item>NameToExtent has all the extents in ExtentList as a dictionary.

            This is used by <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbPropertyExpression)"/> to flatten

            record accesses.</item>

            <item>IsNestedJoin - is used to determine whether a JoinSymbol is an

            ordinary join symbol, or one that has a corresponding SqlSelectStatement.</item>

            </list>

            All the lists are set exactly once, and then used for lookups/enumerated.

            </summary>

        </member>

        <member name="T:System.Data.SQLite.Linq.Symbol">

             <summary>

             <see cref="T:System.Data.SQLite.Linq.SymbolTable"/>

             This class represents an extent/nested select statement,

             or a column.

             The important fields are Name, Type and NewName.

             NewName starts off the same as Name, and is then modified as necessary.

             The rest are used by special symbols.

             e.g. NeedsRenaming is used by columns to indicate that a new name must

             be picked for the column in the second phase of translation.

             IsUnnest is used by symbols for a collection expression used as a from clause.

             This allows <see cref="M:System.Data.SQLite.Linq.SqlGenerator.AddFromSymbol(System.Data.SQLite.Linq.SqlSelectStatement,System.String,System.Data.SQLite.Linq.Symbol,System.Boolean)"/> to add the column list

             after the alias.

             </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.Symbol.WriteSql(System.Data.SQLite.Linq.SqlWriter,System.Data.SQLite.Linq.SqlGenerator)">

             <summary>

             Write this symbol out as a string for sql.  This is just

             the new name of the symbol (which could be the same as the old name).

             We rename columns here if necessary.

             </summary>

             <param name="writer"></param>

             <param name="sqlGenerator"></param>

        </member>

        <member name="T:System.Data.SQLite.Linq.MetadataHelpers">

            <summary>

            A set of static helpers for type metadata

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.NullableFacetName">

            <summary>

            Name of the Nullable Facet

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.GetEdmType``1(System.Data.Metadata.Edm.TypeUsage)">

            <summary>

            Cast the EdmType of the given type usage to the given TEdmType

            </summary>

            <typeparam name="TEdmType"></typeparam>

            <param name="typeUsage"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.GetElementTypeUsage(System.Data.Metadata.Edm.TypeUsage)">

            <summary>

            Gets the TypeUsage of the elment if the given type is a collection type

            </summary>

            <param name="type"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.GetProperties(System.Data.Metadata.Edm.TypeUsage)">

            <summary>

            Retrieves the properties of in the EdmType underlying the input type usage,

             if that EdmType is a structured type (EntityType, RowType).

            </summary>

            <param name="typeUsage"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.GetProperties(System.Data.Metadata.Edm.EdmType)">

            <summary>

            Retrieves the properties of the given EdmType, if it is

             a structured type (EntityType, RowType).

            </summary>

            <param name="edmType"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.IsCollectionType(System.Data.Metadata.Edm.TypeUsage)">

            <summary>

            Is the given type usage over a collection type

            </summary>

            <param name="typeUsage"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.IsCollectionType(System.Data.Metadata.Edm.EdmType)">

            <summary>

            Is the given type a collection type

            </summary>

            <param name="type"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.IsPrimitiveType(System.Data.Metadata.Edm.TypeUsage)">

            <summary>

            Is the given type usage over a primitive type

            </summary>

            <param name="type"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.IsPrimitiveType(System.Data.Metadata.Edm.EdmType)">

            <summary>

            Is the given type a primitive type

            </summary>

            <param name="type"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.IsRowType(System.Data.Metadata.Edm.TypeUsage)">

            <summary>

            Is the given type usage over a row type

            </summary>

            <param name="type"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.IsRowType(System.Data.Metadata.Edm.EdmType)">

            <summary>

            Is the given type a row type

            </summary>

            <param name="type"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.TryGetPrimitiveTypeKind(System.Data.Metadata.Edm.TypeUsage,System.Data.Metadata.Edm.PrimitiveTypeKind@)">

            <summary>

            Gets the type of the given type usage if it is a primitive type

            </summary>

            <param name="type"></param>

            <param name="typeKind"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.TryGetValueForMetadataProperty``1(System.Data.Metadata.Edm.MetadataItem,System.String)">

            <summary>

            Gets the value for the metadata property with the given name

            </summary>

            <typeparam name="T"></typeparam>

            <param name="item"></param>

            <param name="propertyName"></param>

            <returns></returns>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.MaxLengthFacetName">

            <summary>

            Name of the MaxLength Facet

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.UnicodeFacetName">

            <summary>

            Name of the Unicode Facet

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.FixedLengthFacetName">

            <summary>

            Name of the FixedLength Facet

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.PreserveSecondsFacetName">

            <summary>

            Name of the PreserveSeconds Facet

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.PrecisionFacetName">

            <summary>

            Name of the Precision Facet

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.ScaleFacetName">

            <summary>

            Name of the Scale Facet

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.MetadataHelpers.DefaultValueFacetName">

            <summary>

            Name of the DefaultValue Facet

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.GetFacetValueOrDefault``1(System.Data.Metadata.Edm.TypeUsage,System.String,``0)">

            <summary>

            Get the value specified on the given type usage for the given facet name.

            If the faces does not have a value specifid or that value is null returns

            the default value for that facet.

            </summary>

            <typeparam name="T"></typeparam>

            <param name="type"></param>

            <param name="facetName"></param>

            <param name="defaultValue"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.MetadataHelpers.TryGetTypeFacetDescriptionByName(System.Data.Metadata.Edm.EdmType,System.String,System.Data.Metadata.Edm.FacetDescription@)">

            <summary>

            Given a facet name and an EdmType, tries to get that facet's description.

            </summary>

            <param name="edmType"></param>

            <param name="facetName"></param>

            <param name="facetDescription"></param>

            <returns></returns>

        </member>

        <member name="T:System.Data.SQLite.Linq.SkipClause">

            <summary>

            SkipClause represents the a SKIP expression in a SqlSelectStatement.

            It has a count property, which indicates how many rows should be skipped.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.SkipClause.#ctor(System.Data.SQLite.Linq.ISqlFragment)">

            <summary>

            Creates a SkipClause with the given skipCount.

            </summary>

            <param name="skipCount"></param>

        </member>

        <member name="M:System.Data.SQLite.Linq.SkipClause.#ctor(System.Int32)">

            <summary>

            Creates a SkipClause with the given skipCount.

            </summary>

            <param name="skipCount"></param>

        </member>

        <member name="M:System.Data.SQLite.Linq.SkipClause.WriteSql(System.Data.SQLite.Linq.SqlWriter,System.Data.SQLite.Linq.SqlGenerator)">

            <summary>

            Write out the SKIP part of sql select statement

            It basically writes OFFSET (X).

            </summary>

            <param name="writer"></param>

            <param name="sqlGenerator"></param>

        </member>

        <member name="P:System.Data.SQLite.Linq.SkipClause.SkipCount">

            <summary>

            How many rows should be skipped.

            </summary>

        </member>

        <member name="T:System.Data.SQLite.Linq.SqlBuilder">

            <summary>

            This class is like StringBuilder.  While traversing the tree for the first time,

            we do not know all the strings that need to be appended e.g. things that need to be

            renamed, nested select statements etc.  So, we use a builder that can collect

            all kinds of sql fragments.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlBuilder.Append(System.Object)">

            <summary>

            Add an object to the list - we do not verify that it is a proper sql fragment

            since this is an internal method.

            </summary>

            <param name="s"></param>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlBuilder.AppendLine">

            <summary>

            This is to pretty print the SQL.  The writer <see cref="M:System.Data.SQLite.Linq.SqlWriter.Write(System.String)"/>

            needs to know about new lines so that it can add the right amount of

            indentation at the beginning of lines.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlBuilder.WriteSql(System.Data.SQLite.Linq.SqlWriter,System.Data.SQLite.Linq.SqlGenerator)">

            <summary>

            We delegate the writing of the fragment to the appropriate type.

            </summary>

            <param name="writer"></param>

            <param name="sqlGenerator"></param>

        </member>

        <member name="P:System.Data.SQLite.Linq.SqlBuilder.IsEmpty">

            <summary>

            Whether the builder is empty.  This is used by the <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbProjectExpression)"/>

            to determine whether a sql statement can be reused.

            </summary>

        </member>

        <member name="T:System.Data.SQLite.Linq.SqlGenerator">

             <summary>

             Translates the command object into a SQL string that can be executed on

             SQLite.

             </summary>

             <remarks>

             The translation is implemented as a visitor <see cref="T:System.Data.Common.CommandTrees.DbExpressionVisitor`1"/>

             over the query tree.  It makes a single pass over the tree, collecting the sql

             fragments for the various nodes in the tree <see cref="T:System.Data.SQLite.Linq.ISqlFragment"/>.

             The major operations are

             <list type="bullet">

             <item>Select statement minimization.  Multiple nodes in the query tree

             that can be part of a single SQL select statement are merged. e.g. a

             Filter node that is the input of a Project node can typically share the

             same SQL statement.</item>

             <item>Alpha-renaming.  As a result of the statement minimization above, there

             could be name collisions when using correlated subqueries

             <example>

             <code>

             Filter(

                 b = Project( c.x

                     c = Extent(foo)

                     )

                 exists (

                     Filter(

                         c = Extent(foo)

                         b.x = c.x

                         )

                 )

             )

             </code>

             The first Filter, Project and Extent will share the same SQL select statement.

             The alias for the Project i.e. b, will be replaced with c.

             If the alias c for the Filter within the exists clause is not renamed,

             we will get <c>c.x = c.x</c>, which is incorrect.

             Instead, the alias c within the second filter should be renamed to c1, to give

             <c>c.x = c1.x</c> i.e. b is renamed to c, and c is renamed to c1.

             </example>

             </item>

             <item>Join flattening.  In the query tree, a list of join nodes is typically

             represented as a tree of Join nodes, each with 2 children. e.g.

             <example>

             <code>

             a = Join(InnerJoin

                 b = Join(CrossJoin

                     c = Extent(foo)

                     d = Extent(foo)

                     )

                 e = Extent(foo)

                 on b.c.x = e.x

                 )

             </code>

             If translated directly, this will be translated to

             <code>

             FROM ( SELECT c.*, d.*

                     FROM foo as c

                     CROSS JOIN foo as d) as b

             INNER JOIN foo as e on b.x' = e.x

             </code>

             It would be better to translate this as

             <code>

             FROM foo as c

             CROSS JOIN foo as d

             INNER JOIN foo as e on c.x = e.x

             </code>

             This allows the optimizer to choose an appropriate join ordering for evaluation.

             </example>

             </item>

             <item>Select * and column renaming.  In the example above, we noticed that

             in some cases we add <c>SELECT * FROM ...</c> to complete the SQL

             statement. i.e. there is no explicit PROJECT list.

             In this case, we enumerate all the columns available in the FROM clause

             This is particularly problematic in the case of Join trees, since the columns

             from the extents joined might have the same name - this is illegal.  To solve

             this problem, we will have to rename columns if they are part of a SELECT *

             for a JOIN node - we do not need renaming in any other situation.

             <see cref="M:System.Data.SQLite.Linq.SqlGenerator.AddDefaultColumns(System.Data.SQLite.Linq.SqlSelectStatement)"/>.

             </item>

             </list>

             <para>

             Renaming issues.

             When rows or columns are renamed, we produce names that are unique globally

             with respect to the query.  The names are derived from the original names,

             with an integer as a suffix. e.g. CustomerId will be renamed to CustomerId1,

             CustomerId2 etc.

             Since the names generated are globally unique, they will not conflict when the

             columns of a JOIN SELECT statement are joined with another JOIN.

             </para>

             <para>

             Record flattening.

             SQL server does not have the concept of records.  However, a join statement

             produces records.  We have to flatten the record accesses into a simple

             <c>alias.column</c> form.  <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbPropertyExpression)"/>

             </para>

             <para>

             Building the SQL.

             There are 2 phases

             <list type="numbered">

             <item>Traverse the tree, producing a sql builder <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/></item>

             <item>Write the SqlBuilder into a string, renaming the aliases and columns

             as needed.</item>

             </list>

             In the first phase, we traverse the tree.  We cannot generate the SQL string

             right away, since

             <list type="bullet">

             <item>The WHERE clause has to be visited before the from clause.</item>

             <item>extent aliases and column aliases need to be renamed.  To minimize

             renaming collisions, all the names used must be known, before any renaming

             choice is made.</item>

             </list>

             To defer the renaming choices, we use symbols <see cref="T:System.Data.SQLite.Linq.Symbol"/>.  These

             are renamed in the second phase.

             Since visitor methods cannot transfer information to child nodes through

             parameters, we use some global stacks,

             <list type="bullet">

             <item>A stack for the current SQL select statement.  This is needed by

             <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbVariableReferenceExpression)"/> to create a

             list of free variables used by a select statement.  This is needed for

             alias renaming.

             </item>

             <item>A stack for the join context.  When visiting a <see cref="T:System.Data.Common.CommandTrees.DbScanExpression"/>,

             we need to know whether we are inside a join or not.  If we are inside

             a join, we do not create a new SELECT statement.</item>

             </list>

             </para>

             <para>

             Global state.

             To enable renaming, we maintain

             <list type="bullet">

             <item>The set of all extent aliases used.</item>

             <item>The set of all column aliases used.</item>

             </list>

             Finally, we have a symbol table to lookup variable references.  All references

             to the same extent have the same symbol.

             </para>

             <para>

             Sql select statement sharing.

             Each of the relational operator nodes

             <list type="bullet">

             <item>Project</item>

             <item>Filter</item>

             <item>GroupBy</item>

             <item>Sort/OrderBy</item>

             </list>

             can add its non-input (e.g. project, predicate, sort order etc.) to

             the SQL statement for the input, or create a new SQL statement.

             If it chooses to reuse the input's SQL statement, we play the following

             symbol table trick to accomplish renaming.  The symbol table entry for

             the alias of the current node points to the symbol for the input in

             the input's SQL statement.

             <example>

             <code>

             Project(b.x

                 b = Filter(

                     c = Extent(foo)

                     c.x = 5)

                 )

             </code>

             The Extent node creates a new SqlSelectStatement.  This is added to the

             symbol table by the Filter as {c, Symbol(c)}.  Thus, <c>c.x</c> is resolved to

             <c>Symbol(c).x</c>.

             Looking at the project node, we add {b, Symbol(c)} to the symbol table if the

             SQL statement is reused, and {b, Symbol(b)}, if there is no reuse.

             Thus, <c>b.x</c> is resolved to <c>Symbol(c).x</c> if there is reuse, and to

             <c>Symbol(b).x</c> if there is no reuse.

             </example>

             </para>

             </remarks>

        </member>

        <member name="F:System.Data.SQLite.Linq.SqlGenerator.selectStatementStack">

            <summary>

            Every relational node has to pass its SELECT statement to its children

            This allows them (DbVariableReferenceExpression eventually) to update the list of

            outer extents (free variables) used by this select statement.

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.SqlGenerator.isParentAJoinStack">

            <summary>

            Nested joins and extents need to know whether they should create

            a new Select statement, or reuse the parent's.  This flag

            indicates whether the parent is a join or not.

            </summary>

        </member>

        <member name="F:System.Data.SQLite.Linq.SqlGenerator.isVarRefSingle">

            <summary>

            VariableReferenceExpressions are allowed only as children of DbPropertyExpression

            or MethodExpression.  The cheapest way to ensure this is to set the following

            property in DbVariableReferenceExpression and reset it in the allowed parent expressions.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.InitializeBuiltInFunctionHandlers">

            <summary>

            All special built-in functions and their handlers

            </summary>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.InitializeCanonicalFunctionHandlers">

            <summary>

            All special non-aggregate canonical functions and their handlers

            </summary>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.InitializeDatepartKeywords">

            <summary>

            Valid datepart values

            </summary>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.InitializeFunctionNameToOperatorDictionary">

            <summary>

            Initializes the mapping from functions to T-SQL operators

            for all functions that translate to T-SQL operators

            </summary>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.#ctor(System.Data.SQLite.Linq.SQLiteProviderManifest)">

            <summary>

            Basic constructor.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.GenerateSql(System.Data.SQLite.Linq.SQLiteProviderManifest,System.Data.Common.CommandTrees.DbCommandTree,System.Collections.Generic.List{System.Data.Common.DbParameter}@,System.Data.CommandType@)">

            <summary>

            General purpose static function that can be called from System.Data assembly

            </summary>

            <param name="manifest"></param>

            <param name="tree">command tree</param>

            <param name="parameters">Parameters to add to the command tree corresponding

            to constants in the command tree. Used only in ModificationCommandTrees.</param>

            <param name="commandType"></param>

            <returns>The string representing the SQL to be executed.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.GenerateSql(System.Data.Common.CommandTrees.DbQueryCommandTree)">

             <summary>

             Translate a command tree to a SQL string.

             The input tree could be translated to either a SQL SELECT statement

             or a SELECT expression.  This choice is made based on the return type

             of the expression

             CollectionType => select statement

             non collection type => select expression

             </summary>

             <param name="tree"></param>

             <returns>The string representing the SQL to be executed.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.GenerateFunctionSql(System.Data.Common.CommandTrees.DbFunctionCommandTree,System.Data.CommandType@)">

            <summary>

            Translate a function command tree to a SQL string.

            </summary>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.WriteSql(System.Data.SQLite.Linq.ISqlFragment)">

            <summary>

            Convert the SQL fragments to a string.

            We have to setup the Stream for writing.

            </summary>

            <param name="sqlStatement"></param>

            <returns>A string representing the SQL to be executed.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbAndExpression)">

            <summary>

            Translate(left) AND Translate(right)

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/>.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbApplyExpression)">

            <summary>

            An apply is just like a join, so it shares the common join processing

            in <see cref="M:System.Data.SQLite.Linq.SqlGenerator.VisitJoinExpression(System.Collections.Generic.IList{System.Data.Common.CommandTrees.DbExpressionBinding},System.Data.Common.CommandTrees.DbExpressionKind,System.String,System.Data.Common.CommandTrees.DbExpression)"/>

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlSelectStatement"/>.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbArithmeticExpression)">

            <summary>

            For binary expressions, we delegate to <see cref="M:System.Data.SQLite.Linq.SqlGenerator.VisitBinaryExpression(System.String,System.Data.Common.CommandTrees.DbExpression,System.Data.Common.CommandTrees.DbExpression)"/>.

            We handle the other expressions directly.

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbCaseExpression)">

            <summary>

            If the ELSE clause is null, we do not write it out.

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbCastExpression)">

             <summary>

             </summary>

             <param name="e"></param>

             <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbComparisonExpression)">

            <summary>

            The parser generates Not(Equals(...)) for <>.

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/>.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbConstantExpression)">

            <summary>

            Constants will be send to the store as part of the generated TSQL, not as parameters

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/>.  Strings are wrapped in single

            quotes and escaped.  Numbers are written literally.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbDerefExpression)">

            <summary>

            <see cref="T:System.Data.Common.CommandTrees.DbDerefExpression"/> is illegal at this stage

            </summary>

            <param name="e"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbDistinctExpression)">

            <summary>

            The DISTINCT has to be added to the beginning of SqlSelectStatement.Select,

            but it might be too late for that.  So, we use a flag on SqlSelectStatement

            instead, and add the "DISTINCT" in the second phase.

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlSelectStatement"/></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbElementExpression)">

            <summary>

            An element expression returns a scalar - so it is translated to

            ( Select ... )

            </summary>

            <param name="e"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbExceptExpression)">

            <summary>

            <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbUnionAllExpression)"/>

            </summary>

            <param name="e"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbExpression)">

            <summary>

            Only concrete expression types will be visited.

            </summary>

            <param name="e"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbScanExpression)">

             <summary>

             </summary>

             <param name="e"></param>

             <returns>If we are in a Join context, returns a <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/>

             with the extent name, otherwise, a new <see cref="T:System.Data.SQLite.Linq.SqlSelectStatement"/>

             with the From field set.</returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.GetTargetTSql(System.Data.Metadata.Edm.EntitySetBase)">

            <summary>

            Gets escaped TSql identifier describing this entity set.

            </summary>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbFilterExpression)">

            <summary>

            The bodies of <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbFilterExpression)"/>, <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbGroupByExpression)"/>,

            <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbProjectExpression)"/>, <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbSortExpression)"/> are similar.

            Each does the following.

            <list type="number">

            <item> Visit the input expression</item>

            <item> Determine if the input's SQL statement can be reused, or a new

            one must be created.</item>

            <item>Create a new symbol table scope</item>

            <item>Push the Sql statement onto a stack, so that children can

            update the free variable list.</item>

            <item>Visit the non-input expression.</item>

            <item>Cleanup</item>

            </list>

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlSelectStatement"/></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbFunctionExpression)">

            <summary>

            Lambda functions are not supported.

            The functions supported are:

            <list type="number">

            <item>Canonical Functions - We recognize these by their dataspace, it is DataSpace.CSpace</item>

            <item>Store Functions - We recognize these by the BuiltInAttribute and not being Canonical</item>

            <item>User-defined Functions - All the rest except for Lambda functions</item>

            </list>

            We handle Canonical and Store functions the same way: If they are in the list of functions

            that need special handling, we invoke the appropriate handler, otherwise we translate them to

            FunctionName(arg1, arg2, ..., argn).

            We translate user-defined functions to NamespaceName.FunctionName(arg1, arg2, ..., argn).

            </summary>

            <param name="e"></param>

            <returns>A <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbEntityRefExpression)">

            <summary>

            <see cref="T:System.Data.Common.CommandTrees.DbEntityRefExpression"/> is illegal at this stage

            </summary>

            <param name="e"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbRefKeyExpression)">

            <summary>

            <see cref="T:System.Data.Common.CommandTrees.DbRefKeyExpression"/> is illegal at this stage

            </summary>

            <param name="e"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbGroupByExpression)">

             <summary>

             <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbFilterExpression)"/> for general details.

             We modify both the GroupBy and the Select fields of the SqlSelectStatement.

             GroupBy gets just the keys without aliases,

             and Select gets the keys and the aggregates with aliases.

             Whenever there exists at least one aggregate with an argument that is not is not a simple

             <see cref="T:System.Data.Common.CommandTrees.DbPropertyExpression"/>  over <see cref="T:System.Data.Common.CommandTrees.DbVariableReferenceExpression"/>,

             we create a nested query in which we alias the arguments to the aggregates.

             That is due to the following two limitations of Sql Server:

             <list type="number">

             <item>If an expression being aggregated contains an outer reference, then that outer

             reference must be the only column referenced in the expression </item>

             <item>Sql Server cannot perform an aggregate function on an expression containing

             an aggregate or a subquery. </item>

             </list>

             The default translation, without inner query is:

                 SELECT

                     kexp1 AS key1, kexp2 AS key2,... kexpn AS keyn,

                     aggf1(aexpr1) AS agg1, .. aggfn(aexprn) AS aggn

                 FROM input AS a

                 GROUP BY kexp1, kexp2, .. kexpn

             When we inject an innner query, the equivalent translation is:

                 SELECT

                     key1 AS key1, key2 AS key2, .. keyn AS keys,

                     aggf1(agg1) AS agg1, aggfn(aggn) AS aggn

                 FROM (

                         SELECT

                             kexp1 AS key1, kexp2 AS key2,... kexpn AS keyn,

                             aexpr1 AS agg1, .. aexprn AS aggn

                         FROM input AS a

                     ) as a

                 GROUP BY key1, key2, keyn

             </summary>

             <param name="e"></param>

             <returns>A <see cref="T:System.Data.SQLite.Linq.SqlSelectStatement"/></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbIntersectExpression)">

            <summary>

            <see cref="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbUnionAllExpression)"/>

            </summary>

            <param name="e"></param>

            <returns></returns>

        </member>

        <member name="M:System.Data.SQLite.Linq.SqlGenerator.Visit(System.Data.Common.CommandTrees.DbIsEmptyExpression)">

             <summary>

             Not(IsEmpty) has to be handled specially, so we delegate to

             <see cref="M:System.Data.SQLite.Linq.SqlGenerator.VisitIsEmptyExpression(System.Data.Common.CommandTrees.DbIsEmptyExpression,System.Boolean)"/>.

             </summary>

             <param name="e"></param>

             <returns>A <see cref="T:System.Data.SQLite.Linq.SqlBuilder"/>.

             <code>[NOT] EXISTS( ... )</code>