Merge branch 'master' into circleci

Author: ajnavarro

blobs.go

@@ -50,8 +50,14 @@ var _ Squashable = (*blobsTable)(nil)
 func (blobsTable) isSquashable()   {}
 func (blobsTable) isGitbaseTable() {}
 
-func (blobsTable) String() string {
-	return printTable(BlobsTableName, BlobsSchema)
+func (r blobsTable) String() string {
+	return printTable(
+		BlobsTableName,
+		BlobsSchema,
+		r.projection,
+		r.filters,
+		r.index,
+	)
 }
 
 func (blobsTable) Name() string {

commit_blobs.go

@@ -33,8 +33,14 @@ var _ Squashable = (*blobsTable)(nil)
 func (commitBlobsTable) isSquashable()   {}
 func (commitBlobsTable) isGitbaseTable() {}
 
-func (commitBlobsTable) String() string {
-	return printTable(CommitBlobsTableName, CommitBlobsSchema)
+func (t commitBlobsTable) String() string {
+	return printTable(
+		CommitBlobsTableName,
+		CommitBlobsSchema,
+		nil,
+		t.filters,
+		t.index,
+	)
 }
 
 func (commitBlobsTable) Name() string { return CommitBlobsTableName }

commit_files.go

@@ -38,8 +38,14 @@ var _ Squashable = (*commitFilesTable)(nil)
 func (commitFilesTable) isSquashable()   {}
 func (commitFilesTable) isGitbaseTable() {}
 
-func (commitFilesTable) String() string {
-	return printTable(CommitFilesTableName, CommitFilesSchema)
+func (t commitFilesTable) String() string {
+	return printTable(
+		CommitFilesTableName,
+		CommitFilesSchema,
+		nil,
+		t.filters,
+		t.index,
+	)
 }
 
 func (commitFilesTable) Name() string { return CommitFilesTableName }

commit_trees.go

@@ -34,8 +34,14 @@ var _ Squashable = (*commitTreesTable)(nil)
 func (commitTreesTable) isSquashable()   {}
 func (commitTreesTable) isGitbaseTable() {}
 
-func (commitTreesTable) String() string {
-	return printTable(CommitTreesTableName, CommitTreesSchema)
+func (t commitTreesTable) String() string {
+	return printTable(
+		CommitTreesTableName,
+		CommitTreesSchema,
+		nil,
+		t.filters,
+		t.index,
+	)
 }
 
 func (commitTreesTable) Name() string { return CommitTreesTableName }

commits.go

@@ -40,8 +40,14 @@ var _ Squashable = (*commitsTable)(nil)
 func (commitsTable) isSquashable()   {}
 func (commitsTable) isGitbaseTable() {}
 
-func (commitsTable) String() string {
-	return printTable(CommitsTableName, CommitsSchema)
+func (r commitsTable) String() string {
+	return printTable(
+		CommitsTableName,
+		CommitsSchema,
+		nil,
+		r.filters,
+		r.index,
+	)
 }
 
 func (commitsTable) Name() string {

files.go

@@ -149,8 +149,14 @@ func (filesTable) handledColumns() []string {
 	return []string{"repository_id", "tree_hash", "blob_hash", "file_path"}
 }
 
-func (filesTable) String() string {
-	return printTable(FilesTableName, FilesSchema)
+func (r filesTable) String() string {
+	return printTable(
+		FilesTableName,
+		FilesSchema,
+		r.projection,
+		r.filters,
+		r.index,
+	)
 }
 
 // IndexKeyValues implements the sql.IndexableTable interface.

internal/rule/squashjoins.go

@@ -392,6 +392,23 @@ func buildSquashedTable(
 				}
 			case nil:
 				var f sql.Expression
+				var refIt gitbase.RefsIter
+
+				if index == nil {
+					f, filters, err = transferFilters(
+						filters,
+						gitbase.RefCommitsTableName,
+						gitbase.ReferencesTableName,
+						gitbase.RefsSchema,
+						"ref_name", "repository_id",
+					)
+					if err != nil {
+						return nil, err
+					}
+
+					refIt = gitbase.NewAllRefsIter(f, true)
+				}
+
 				f, filters, err = filtersForTable(
 					gitbase.RefCommitsTableName,
 					filters,
@@ -404,7 +421,7 @@ func buildSquashedTable(
 				if index != nil {
 					iter = gitbase.NewIndexRefCommitsIter(index, f)
 				} else {
-					iter = gitbase.NewAllRefCommitsIter(f)
+					iter = gitbase.NewRefRefCommitsIter(refIt, f)
 				}
 			default:
 				addUnsquashable(gitbase.RefCommitsTableName)
@@ -1141,6 +1158,35 @@ func filtersForTables(
 	return
 }
 
+func filtersForColumns(
+	filters []sql.Expression,
+	table string,
+	columns ...string,
+) (columnFilters []sql.Expression, remaining []sql.Expression) {
+	var fTable []sql.Expression
+	fTable, remaining = filtersForTables(filters, table)
+
+	for _, f := range fTable {
+		valid := true
+		expression.Inspect(f, func(e sql.Expression) bool {
+			gf, ok := e.(*expression.GetField)
+			if ok && !stringInSlice(columns, gf.Name()) {
+				valid = false
+				return false
+			}
+
+			return true
+		})
+
+		if valid {
+			columnFilters = append(columnFilters, f)
+		} else {
+			remaining = append(remaining, f)
+		}
+	}
+
+	return
+}
 func stringInSlice(strs []string, str string) bool {
 	for _, s := range strs {
 		if s == str {
@@ -1572,6 +1618,51 @@ func fixFieldIndexes(e sql.Expression, schema sql.Schema) (sql.Expression, error
 	})
 }
 
+func transferFilters(
+	filters []sql.Expression,
+	from, to string,
+	schema sql.Schema,
+	columns ...string,
+) (sql.Expression, []sql.Expression, error) {
+	f, r := filtersForColumns(filters, from, columns...)
+	fixed, err := fixFieldTable(expression.JoinAnd(f...), to, schema)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return fixed, r, err
+}
+
+func fixFieldTable(
+	e sql.Expression,
+	table string,
+	schema sql.Schema,
+) (sql.Expression, error) {
+	if e == nil {
+		return nil, nil
+	}
+	return e.TransformUp(func(e sql.Expression) (sql.Expression, error) {
+		gf, ok := e.(*expression.GetField)
+		if !ok {
+			return e, nil
+		}
+
+		for idx, col := range schema {
+			if gf.Name() == col.Name {
+				return expression.NewGetFieldWithTable(
+					idx,
+					gf.Type(),
+					table,
+					gf.Name(),
+					gf.IsNullable(),
+				), nil
+			}
+		}
+
+		return nil, analyzer.ErrColumnTableNotFound.New(gf.Table(), gf.Name())
+	})
+}
+
 func filterDiff(a, b []sql.Expression) []sql.Expression {
 	var result []sql.Expression
 

ref_commits.go

@@ -37,8 +37,14 @@ var _ Squashable = (*refCommitsTable)(nil)
 func (refCommitsTable) isSquashable()   {}
 func (refCommitsTable) isGitbaseTable() {}
 
-func (refCommitsTable) String() string {
-	return printTable(RefCommitsTableName, RefCommitsSchema)
+func (t refCommitsTable) String() string {
+	return printTable(
+		RefCommitsTableName,
+		RefCommitsSchema,
+		nil,
+		t.filters,
+		t.index,
+	)
 }
 
 func (refCommitsTable) Name() string { return RefCommitsTableName }

references.go

@@ -36,7 +36,13 @@ func (referencesTable) isSquashable()   {}
 func (referencesTable) isGitbaseTable() {}
 
 func (r referencesTable) String() string {
-	return printTable(ReferencesTableName, RefsSchema)
+	return printTable(
+		ReferencesTableName,
+		RefsSchema,
+		nil,
+		r.filters,
+		r.index,
+	)
 }
 
 func (referencesTable) Name() string {

remotes.go

@@ -44,7 +44,13 @@ func (remotesTable) Schema() sql.Schema {
 }
 
 func (r remotesTable) String() string {
-	return printTable(RemotesTableName, RemotesSchema)
+	return printTable(
+		RemotesTableName,
+		RemotesSchema,
+		nil,
+		r.filters,
+		r.index,
+	)
 }
 
 func (r *remotesTable) WithFilters(filters []sql.Expression) sql.Table {