System.Data.SQLite

    /// <param name="strTable">The table to retrieve index information for, can be null</param>
    /// <returns>DataTable</returns>
    private DataTable Schema_Indexes(string strCatalog, string strTable, string strIndex)
    {
      DataTable tbl = new DataTable("Indexes");
      DataRow row;
      DataTable tblSchema;
      Collections.Generic.List<int> primaryKeys = new List<int>();
      bool maybeRowId;

      tbl.Locale = CultureInfo.InvariantCulture;
      tbl.Columns.Add("TABLE_CATALOG", typeof(string));
      tbl.Columns.Add("TABLE_SCHEMA", typeof(string));
      tbl.Columns.Add("TABLE_NAME", typeof(string));
      tbl.Columns.Add("INDEX_CATALOG", typeof(string));
      tbl.Columns.Add("INDEX_SCHEMA", typeof(string));

      using (SQLiteCommand cmdTables = new SQLiteCommand(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM [{0}].[sqlite_master] WHERE [type] LIKE 'table'", strCatalog), this))
      {
        using (SQLiteDataReader rdTables = cmdTables.ExecuteReader())
        {
          while (rdTables.Read())
          {
            maybeRowId = false;
            primaryKeys.Clear();
            if (String.IsNullOrEmpty(strTable) || String.Compare(rdTables.GetString(2), strTable, true, CultureInfo.InvariantCulture) == 0)
            {
              // First, look for any rowid indexes -- which sqlite defines are INTEGER PRIMARY KEY columns.
              // Such indexes are not listed in the indexes list but count as indexes just the same.
              using (SQLiteCommand cmdTable = new SQLiteCommand(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM [{0}].[{1}]", strCatalog, rdTables.GetString(2)), this))
              {
                using (SQLiteDataReader rdTable = cmdTable.ExecuteReader(CommandBehavior.SchemaOnly))
                {
                  tblSchema = rdTable.GetSchemaTable(false);
                  foreach (DataRow schemaRow in tblSchema.Rows)
                  {
                    if (schemaRow.IsNull("DeclaredType") == false)
                    {
                      if ((bool)schemaRow[SchemaTableColumn.IsKey] == true)
                      {

                        primaryKeys.Add((int)schemaRow[SchemaTableColumn.ColumnOrdinal]);





                        // If the primary key is of type INTEGER, then its a rowid and we need to make a fake index entry for it.
                        if (String.Compare((string)schemaRow["DeclaredType"], "INTEGER", true, CultureInfo.InvariantCulture) == 0)
                        {

                          maybeRowId = true;


                        }

                      }
                    }
                  }
                  if (primaryKeys.Count == 1 && maybeRowId == true)
                  {
                    row = tbl.NewRow();

                    row["TABLE_CATALOG"] = strCatalog;
                    row["TABLE_NAME"] = rdTables.GetString(2);
                    row["INDEX_CATALOG"] = strCatalog;
                    row["PRIMARY_KEY"] = true;
                    row["INDEX_NAME"] = String.Format(CultureInfo.InvariantCulture, "sqlite_master_PK_{0}", rdTables.GetString(2));
                    row["UNIQUE"] = true;

                    tbl.Rows.Add(row);
                    primaryKeys.Clear();
                  }
                }
              }

              // Now fetch all the rest of the indexes.
              using (SQLiteCommand cmd = new SQLiteCommand(String.Format(CultureInfo.InvariantCulture, "PRAGMA [{0}].index_list([{1}])", strCatalog, rdTables.GetString(2)), this))
              {

                      row = tbl.NewRow();

                      row["TABLE_CATALOG"] = strCatalog;
                      row["TABLE_NAME"] = rdTables.GetString(2);
                      row["INDEX_CATALOG"] = strCatalog;
                      row["INDEX_NAME"] = rd.GetString(1);
                      row["UNIQUE"] = rd.GetBoolean(2);
                      row["PRIMARY_KEY"] = false;

                      // Now for the really hard work.  Figure out which index is the primary key index.
                      // The only way to figure it out is to check if the index was an autoindex and if we have a non-rowid
                      // primary key, and all the columns in the given index match the primary key columns
                      if (primaryKeys.Count > 0 && rd.GetString(1).StartsWith("sqlite_autoindex_" + rdTables.GetString(2), StringComparison.InvariantCultureIgnoreCase) == true)
                      {
                        using (SQLiteCommand cmdDetails = new SQLiteCommand(String.Format(CultureInfo.InvariantCulture, "PRAGMA [{0}].index_info([{1}])", strCatalog, rd.GetString(1)), this))
                        {
                          using (SQLiteDataReader rdDetails = cmdDetails.ExecuteReader())
                          {
                            int nMatches = 0;
                            while (rdDetails.Read())
                            {
                              if (primaryKeys.Contains(rdDetails.GetInt32(1)) == false)
                              {
                                nMatches = 0;
                                break;
                              }
                              nMatches++;
                            }
                            if (nMatches == primaryKeys.Count)
                            {
                              row["PRIMARY_KEY"] = true;
                              primaryKeys.Clear();
                            }
                          }
                        }
                      }

                      tbl.Rows.Add(row);
                    }
                  }
                }
              }
            }