
<EmbeddedYoutubeVideo id="r2CpLe1h89I" />

## Related links

- [Sourcegraph cloud code search](https://sourcegraph.com/search)
- [Sourcegraph docs](https://docs.sourcegraph.com)
- [Read about literal search patterns](/how-to-search-code-with-sourcegraph-using-literal-patterns)
- [Watch: Three Ways to Search with Sourcegraph (Video)](/three-ways-to-search-code-with-sourcegraph)

## Transcript

Have you ever been faced with an error message and spent a really long time trying to figure out where it was coming from?

My name is Marek. I'm an engineer at Sourcegraph. And I'm going to share with you my own error message story.

A few months ago, I was working on a browser extension in Chrome. And I started seeing this unfamiliar message that I hadn't seen before. It looked something like this. "Extension context invalidated." What does that even mean? I didn't know where this error was being thrown. And I didn't know where to start looking. We were loading code from a few different repositories into this browser extension bundle. So I wasn't sure where this was coming from.

At first, I tried doing some searches right in my editor to try to find an exact match for the text of this error message. But I got nowhere. I didn't find any matches in the repository that I had open at all.

So I'll show you how I actually used Sourcegraph to do a code search that helped me find the answer. By default, Sourcegraph searches for code in literal search mode. That means it looks for an exact match. For an error message, this is pretty convenient. And I can show you by pasting that error message directly into the search box. Now, I don't need to surround this search with quotes, because literal search will by default already search for the entire thing.

As soon as I get results, there's a hint about where this is coming from. And that's in the name of this repository that I'm getting. So I'm seeing chromium as the repository. This gives me a hint that this is part of the Chrome browser itself and actually not at all a part of the code base that I was working on. The chromium source code is in a public GitHub repository, and Sourcegraph searches over public code. This helped me save a lot of time and a lot of struggle to get to the bottom of this error message. And it turns out it was an issue with the way that the browser extension was being reloaded for development.

Sourcegraph's default search mode is great for error messages like this, but if you're looking for patterns, you can also use regular expressions. And you can also use structural search. So you can take a look at our documentation to learn more about that.


Finding software error messages with Sourcegraph universal code search

Learn about finding error messages in your code with Sourcegraph.

How to find error messages with Sourcegraph (video)


Sourcegraph is a universal code search tool, enabling you to search across both open source and your own private code repositories. Code search can help you onboard onto new codebases, contribute to open source, find bugs and error messages, understand dependency libraries, and more.

This cheat sheet style guide can help you get up to speed with Sourcegraph commands quickly. For more thorough tutorials on using Sourcegraph, refer to our [tutorials](https://learn.sourcegraph.com/tags/sourcegraph) and our [documentation](https://docs.sourcegraph.com/). 

You can use these commands on either [Sourcegraph cloud](https://sourcegraph.com/search) or your own [Sourcegraph instance](https://docs.sourcegraph.com/admin/install).

## Searching an organization’s repository

By default, Sourcegraph lets you search globally, providing you with results from all the repositories you have access to. On Sourcegraph cloud, this includes all currently indexed open source repositories. The `repo` command lets you dial down to the single repository level.

### Searching for or within a repository

The `repo` keyword lets you search a specific repository in your organization or on the web.

```
repo:[repository-path]
repo:[regular-pattern]
```

Searching with `repo:^github\.com/ORGANIZATION` will return all repositories in a given organization, where `ORGANIZATION` can be `sourcegraph`, for example.

<SourcegraphSearch query="repo:^github\.com/sourcegraph/.*" />


The `repo` keyword contextualizes the searches you perform on Sourcegraph. 

### Repository search: command chaining

When searching a repository, command chaining can be used to return more specific results depending on the expected results.

**Search for a repository that contains a file**

If you are searching for a file in a repository, use `repo.contains.file`.

```
repo:[repository-path] repo.contains.file([file-path])
```

For example, when searching for the `package.json` file in a project, this search query will return the file.


<SourcegraphSearch query="repo:^github\.com/sourcegraph/.* repo:contains.file(package.json)" />


A similar example that uses the content query to search for files is shown below.


<SourcegraphSearch query="repo:contains(file:package\.json$ content:ts)" />


This query returns repositories that contain a `package.json` file and has content written in TypeScript.


**Search for a repository that contains some content**

Suppose you are searching for some content in a repository, such as a library. Use `repo.contains.content`.

```
repo:[repo-path] repo.contains.content([content])
repo:[repo-path] repo.contains.content([regular-pattern])
```

We can search for the `mdi-react` library in Sourcegraph, for example:

<SourcegraphSearch query="repo:^github\.com/sourcegraph/.* repo:contains.content(mdi-react)" />


The above query returns repos that have `mdi-react` among its contents.

## Language-specific search

Use `lang` when searching code to narrow the scope of your search to one programming language. 

```
lang:[programming language]
```

We can search for results within the C++ or Python programming languages.


<SourcegraphSearch query="lang:c++" />

<SourcegraphSearch query="lang:python" />


By default, searches are case insensitive.

Prepending a hyphen can exclude results from a particular programming language.

```
-lang:[programming-language]
```

To exclude Java, you can perform the following search.

<SourcegraphSearch query="​​-lang:java" />

Narrowing your search scope down to specific languages can ensure that you find the code that is most relevant to your needs.

## Searching based on time periods

If you are searching for code committed before or after a time period, you will use `before` and `after`

```
before:[time-period]
after:[time-period]
```

Sometimes the time period can be literal, like `last week`, `last year`, `3 months ago`, `february 10 2021` or have actual dates in the format `dd/mm/yyyy`.

```
before:last week
after:february 10 2021
before:02/01/2019
```

To search between dates, keywords like `and` can be combined with `before` or `after` to return dates within a given period.

<SourcegraphSearch query='repo:sourcegraph type:commit after:"july 9 2021" and before:"july 10 2021"' />

Time-based search is usually used along with other search commands to further narrow down search results.

Note that `before` and `after` only work in conjunction when combined with `type:diff` or `type:commit` commands.

## Search in archived repositories

The `archived` keyword will bring up those results from repositories that have been archived.

```
archived:[yes/only]
archived:yes
archived:only
```

We can surface only archived repositories within the Sourcegraph organization with the following query.

<SourcegraphSearch query="repo:sourcegraph archived:only" />

This can help us understand past decisions made within a given codebase. 

## Case sensitive search

Use `yes` or `no` with the `case` search query to specify if the search should be case sensitive or not. By default, searches are case insensitive.

```
case:[yes/no]
case:yes
case:no
```

Suppose you would like to check to align the style of a given codebase to help you bring all function calls in Python to be consistent with the [PEP 8](https://www.python.org/dev/peps/pep-0008/) guidance. You can use Sourcegraph to understand which functions are using camelCase rather than lowercase names with underscores between words (also called snake_case).

<SourcegraphSearch query="case:yes lang:python myFunction" />


If you would like to find all declared functions that use camelCase, you can try combining this query with regular expressions.

## Searching by types

Types define the scope of code search. A search scope consists of commits, diffs, symbols, repos, paths and files. It is typically used alongside other search commands to further narrow search results.

```
type:[commit|paths|diff|symbol|repo|files]
```

Here is an example to show us time-based commits on the Sourcegraph repo.

<SourcegraphSearch query="repo:sourcegraph after:yesterday type:commit" />

A `type` scope can use the following commands, which will restrict search to the following:
* `commit` — commits to a repository
* `diff` — show [diffs](https://git-scm.com/docs/git-diff), or changes, within a repository
*`repo` — repositories available to you
* `files` — returns files 
*`symbol` — returns files that contain names or keywords in a library.

Searching by type can help you find exactly what you need in a codebase by narrowing down the scope of your search. 

## Searching commit messages matching a string

If a commit message is known, it can be helpful to use the `message` keyword to bring up relevant commits.

```
message:[commit-message]
message:[string-regex-pattern]
```

We can find all commit messages with “fix” in the `sourcegraph/sourcegraph` repository by searching the following.

<SourcegraphSearch query="repo:^github\.com/sourcegraph/sourcegraph$ type:commit message:fix" />

Note that the message keyword only works for `type:diff` or `type:commit` queries.

## Searching code by commits and diffs 

The `author` keyword returns code search results that were created by a user. This keyword only works for `type:diff` or `type:commit` queries.


```
author:[author-name]
```

Adding a hyphen in front of the `author` keyword omits code content created by a given author.

```
-author:[author-name]
```

Search for all code diffs by the Renovate app within our Sourcegraph repository.

<SourcegraphSearch query="repo:^github\.com/sourcegraph/sourcegraph$ author:renovate type:diff" />

You can also search by `committer:git-email` with the same `type` constraints.

## Return a certain number of results

Sourcegraph returns pages filled with search results. To stop searching after a given number of results are returned, use the `count` command.

```
count:[number|all]
```

For example, `count:5` would return the first 5 results of a given query.

<SourcegraphSearch query="repo:sourcegraph/learn type:commit count:5" />

The `all` option returns all results from a search.

The `count` keyword may also be used to return _more_ results, not just  _fewer_ results. This can enable you to display more than the default 500 results that are returned.

## Searching for or within forks

The `fork` keyword restricts the scope of search results to either include, exclude, or return only  forks of a given repository.

```
fork:[yes|no|only]
```

The `yes` option includes forked repositories, the `no` option omits the results from forks, and the `only` option searches only forked repositories.

One use case for searching forked repositories is looking for how users personalize open source libraries.

## Timing out searches

To set the duration before a search times out, you’ll use the `timeout` keyword. Time units that can be used include nanoseconds (`ns`), microseconds (`us` or `µs`) , milliseconds (`ms`), seconds (`s`) or minutes (`m`).

```
timeout:[time-duration-with-unit]
```

This is useful when searching many repositories at the same time to give search more time to return useful results. By default, timeout is 10 seconds, however, when using the `timeout` command, timeouts can be set to over a minute. When this scope is provided, search is given more time to complete.

<SourcegraphSearch query="timeout:40s" />

Alternatively, if you are receiving too many results, you can decrease the time of search.

## Search by repository visibility

Restricting search by codebase visibility is done with the `visibility` command. You can restrict search to public or private repositories.

This is useful if you want the results of a search to be explicitly narrowed down to repositories that are private and accessible to you or repositories that are public. 

Except when explicitly set, all searches return results from both public and private repositories accessible to you.

```
 visibility:[any|private|public]
```

When logged into Sourcegraph, you can change your context to your username and then run the following command to show all of your available private repositories.

<SourcegraphSearch query="visibility:private" />

This can allow you to search across the code that is private to only you. _Please note that searching private code on Sourcegraph cloud is currently in Public Beta._

## Further resources

To learn more about how to search effectively with Sourcegraph, you can read through our Sourcegraph search series:
* [How To Search with Sourcegraph using Literal Patterns](/how-to-search-code-with-sourcegraph-using-literal-patterns)
* [How To Search with Sourcegraph using Regular Expression Patterns](/how-to-search-with-sourcegraph-using-regular-expression-patterns)
* [How To Search with Sourcegraph using Structural Patterns](/how-to-search-with-sourcegraph-using-structural-patterns)

You can also check out [Sourcegraph product documentation](https://docs.sourcegraph.com/) and [Sourcegraph tutorials](https://learn.sourcegraph.com/tags/sourcegraph).


Getting started with Sourcegraph universal code search

A guide to help you get up to speed with Sourcegraph's commands quickly

How to search code with Sourcegraph — a cheat sheet


Sourcegraph code search is a search engine that allows you to search code in your own repositories as well as across public open source code. It supports three kinds of search patterns: literal patterns, regular expression patterns, and structural patterns. In this article, we’ll explore literal search patterns and how to use them.

Performing a literal search is useful when you know the exact string that you’re looking for in a code base, like a particular function or variable name. You can find all occurrences of the name across multiple repositories by using your query as a literal pattern. It’s also useful for finding textual content — like error messages or comments — in the code.

By default, all search queries on Sourcegraph are treated as literal patterns. We’ll discuss a few use cases to find useful results with Sourcegraph.

## Finding function calls and definitions

As a developer, there are many times you may need to learn a new codebase: you may need to understand how best to use a new package, may need to be onboarded into an existing project, or may want to learn best practices from tried and tested software. A productive way to become familiar with a codebase is through selecting a function and understanding how it’s used throughout the code and in what contexts.

For example, if you’re learning how the Linux kernel works, one of the topics that you may want to understand is how Linux uses linked lists. Because linked lists are used throughout the Linux kernel and in driver code, they are a foundational starting point to familiarize yourself with the codebase.

The linked list data structure in Linux is called `list_head`. We can find all instances of the `list_head` structure by searching for it directly:

<SourcegraphSearch query="list_head"/>

As you review the results, you may notice that there are some common functions that are frequently used together with linked lists. One of these functions is `list_add_tail`. To explore further and find all instances of `list_add_tail`, we can start a new search for that specific function:

<SourcegraphSearch query="list_add_tail"/>

Literal search patterns can be used to find more than just functions or variables. They can also be used to find longer pieces of text, like error messages, as we’ll explore in the next section.

## Finding error messages

Literal search can help you find where a particular piece of text occurs within code. For example, if you’re seeing an error message while debugging, it can be helpful to find where that message is defined in the code to get a better idea of what is causing it. You can search for an exact match by copying the error into your search.

Let’s try an example. React is a framework used by many web apps, and its error messages are sometimes hard to debug. When a React component throws an error, it produces an error message like, `React caught an error thrown by Component`. When you get an error message like that, it isn’t always clear what is going on. To learn more about the source of the error, you can search for the error message itself:

<SourcegraphSearch query="React caught an error thrown"/>

By finding where an error message is defined, you can start to understand what conditions will cause this error. In this case, it happens when React catches an error that happened during the rendering phase in one of your components.

This kind of search also gives you an understanding of the inner workings of the codebase, and that can be really helpful to get a better mental model of how it works.

## Finding sequences of words

By default, when searching for literal patterns in Sourcegraph, the entire query will be searched, even if the pattern consists of multiple worlds. You should not put your query in quotes: we’ll go into more detail about this now.

Unlike a web search engine, if you search for two or more words on Sourcegraph, like `const counter`, then you’ll only get results for `const` immediately followed by `counter`, as in the example below.

<SourcegraphSearch query="const counter"/>

Returning to our example in the Linux kernel, we can narrow down our search for `list_head` to only the cases where it’s used as a simple structure ([`struct`][struct]), by searching specifically for the `struct list_head` pattern:

<SourcegraphSearch query="struct list_head"/>

If you want to find all instances of those two words appearing in the same file but not necessarily in sequence, then you can use the `and` operator, or you can switch to regular expression mode.

To use the `and` operator, add it to your search. The following query will find occurrences of `list_head` and `list_add_tail` when they are present anywhere in the same file.

<SourcegraphSearch query="list_head and list_add_tail"/>

If you try one of these examples with quotes around the search query, like `"const counter"`, you’ll notice that you get no results. This is because the quote characters are interpreted literally, so Sourcegraph will search for textual data that includes those quote characters.

There are cases where searching for quote characters is useful. We’ll explore that in the next section.

## Finding quoted string constants

Because quote characters are treated like any other character when you’re in literal pattern mode, you can search for quoted strings by including the quotes in your search.

For example, the quoted string `"ENOENT"` represents the error when a file is not found in Linux, and it’s found in many codebases:

<SourcegraphSearch query='"ENOENT"'/>

By including the quotes in the search query, you can compare this search with the same string, but without quotes. You’ll receive other results, where the string isn’t necessarily in quotes.

<SourcegraphSearch query='ENOENT'/>

## Learn more

We’ve explored how to use Sourcegraph to search for literal patterns like function names, variables names, error messages, and strings. You can learn more about Sourcegraph search syntax in the [documentation].

Literal search patterns are a useful starting point, but often you need to search for patterns in your code that require more flexibility. Sourcegraph offers two other types of patterns: [regular expressions] and [structural search].

To go beyond literal patterns, you can use regular expressions or structural search patterns.

**Related links:**

- [Sourcegraph search query documentation][documentation]
- [Sourcegraph regular expression search][documentation]
- [Sourcegraph structural search][structural search]

[struct]: https://en.wikipedia.org/wiki/Struct_(C_programming_language)
[documentation]: https://docs.sourcegraph.com/code_search/reference/queries
[regular expressions]: https://docs.sourcegraph.com/code_search/reference/queries#regular-expression-search
[structural search]: /how-to-search-with-sourcegraph-using-structural-patterns


Searching code with Sourcegraph using literal search

Learn how to use literal search patterns to search code on Sourcegraph.

How to search code with Sourcegraph using literal patterns


<EmbeddedYoutubeVideo id="_dGkagmwZqU" />

## Transcript

Reading and searching open source code really helps me understand my project dependencies, it helps me optimize my code, and it helps me figure out how to best implement a new feature. I also find that real-life examples in open source code help new developers learn effectively, and can encourage them to become contributors to open source, too!

I’m Lisa, Director of Developer Education at Sourcegraph, and the team here is working on indexing every open source repository on GitHub and GitLab with at least one star. You, too, can add open source repositories to Sourcegraph cloud to help others be able to search across many repos. I’ll walk you through the process.

### Manage repositories from your Sourcegraph cloud account

First, you’ll need to have an account on Sourcegraph cloud. Once you sign up or login, you’ll click on your user icon on the top right corner of the page. From the drop-down menu, click on **Repositories**. If you have repositories on your account already, click through to **Manage Repositories**.

From here you will be able to connect your own repositories to Sourcegraph, but for now, we’re going to scroll down to **Other public repositories**. We’ll click on the checkbox **Sync specific public repositories by URL**. 

### Add links to public repositories

In the box, you can add links to these public repos, whether you contribute to the project or not. These are probably open source projects that you care about. Add one URL per line with no separating characters other than the `ENTER` key.

I have identified two projects that I would like to have Sourcegraph index. One of them is this [Cloud Haiku repository](https://github.com/do-community/cloud_haiku), I’ll go through, copy, and paste. Then I’ll hit `ENTER` to start a new line — don’t put any characters in between. Then I’ll go through and copy paste for the second repository, which is an [archive of computational history](https://github.com/dhmit/computation_hist). When you are satisfied with the repositories that you have added, you can click the **Save** button below. You can always add more repos later!

### Verify that repositories have been added

Once I've clicked on **Save** I should see that these repositories are loaded in, preloaded to my account. And now I can actually check to make sure that Sourcegraph has in fact indexed these repositories by looking for a specific string that I know exists in one of them. So, first I’ll identify that string and share that with you really quickly.

In this Cloud Haiku repository, there is this line, “Like the octopuses’ minds” and a break. I suspect this is not a common line in open source repositories. So what I’m going to do next is open a private or incognito window and then I’m going to search Sourcegraph for this specific line to make sure that it is globally available. 

Now I have my private window, I’m going to go to sourcegraph.com and I’m going to search that line that I mentioned before. So this is “Like the octopuses’ minds” with a break. I am in the context:global search, I am not logged in, and I am going to hit the **Search**. So here we see that there are actually a few instances of this line, but it is limited to this repo. This repo is the one that I just added, so we know that that repository has been indexed by Sourcegraph. Now, even an anonymous user, not logged in, will be able to access the open source repos that I just added. 

Looking forward to seeing the open source repositories that you’ll add to Sourcegraph. Happy coding and happy searching through open source!

## Related links

To learn more about Sourcegraph cloud, check out our full written tutorial on [How to add open source software projects to Sourcegraph cloud](https://learn.sourcegraph.com/how-to-add-open-source-software-projects-to-sourcegraph-cloud) and our tutorial on [How to add private code repositories to Sourcegraph cloud](https://learn.sourcegraph.com/how-to-add-private-code-repositories-to-sourcegraph).


Sourcegraph is indexing open source

Find out how to add open source repos to Sourcegraph cloud so you can search across all the code you care about.

How to add open source software to Sourcegraph cloud (video)


<EmbeddedYoutubeVideo id="f4jEXHn3T74" />

## Transcript

Sourcegraph lets you search over the many repositories of public code that we're indexing on GitHub and GitLab.

If you want to search your own private repositories, you can now do that too by adding your private repositories to your Sourcegraph account.

---

**NOTE**:

_Searching private code is currently in Public Beta._

---

When you add private code to Sourcegraph, it remains private. So it won't show up in anybody else's search results, and you’ll only see it when you're logged in with your account, and no Sourcegraph employee can ever see any private code

My name is Marek, I'm an engineer at Sourcegraph, and I'm going to show you how you can add your own private repositories to Sourcegraph and start searching over your own code.

To start, open the menu in the top right, and go to “Repositories”. You can also find repositories on the “Settings” page. The “Repositories” page is where you can manage any synced repositories that you have. But first, we'll have to connect a code host. So I'll click on “Connect code hosts” to do that.

I happen to have all my repositories on GitHub, so that's the code host that I'd like to connect. I'll do that by clicking the connect button. In order to connect my GitHub account with Sourcegraph, I have to authorize by clicking on the green button here.

Now that I've connected GitHub, I can go to the next step and actually select the repositories that I want to add. And I'll do that by clicking add to your repositories. Now I want to select specific repositories to add. So I'll click on “Sync selected repositories”. And this will give me a list of my repositories that are available. I'm interested in two private repositories that I want to have in Sourcegraph, so I'll select these two. And then I'll click “Save” at the bottom.

Once my repositories are synced, I see them here on this page. I can now go back to the “Search” page to start doing some searches. On the search page, I can now search for code in my private repositories. I can specify that I'm interested in my own private repositories by switching the search context. The search context drop down on the left allows me to do that.

The `global` context is the default context. And that searches over all of the public repositories that have already been indexed by Sourcegraph. The context below is my own username. So, that refers to all the repositories that I've personally added to Sourcegraph. By selecting my username here, I'm going to switch to the context that searches specifically over the code that I added.

Now I can try this out with a search that includes a keyword that I know exists in my private repositories. On the results page, I'm getting results that are coming directly from these repositories that I've added. So now I know that I'm searching over my own private code. No one else will see these results because they are private, so I'm the only user who will be getting access to this repository.

I can click on search results and start browsing my codebase on Sourcegraph. This lets me use Sourcegraph features, like code intelligence when I hover over a token, and find references that show me where a particular symbol is being used.

If you want to learn more about the kinds of things that you can search for, and how to use different search features like filters and types of search, I invite you to take a look at the [documentation](https://docs.sourcegraph.com/) and learn more there.

_For a full tutorial, read "[How to add private code repositories to Sourcegraph cloud](/how-to-add-private-code-repositories-to-sourcegraph)."_

Connecting private software repos to your Sourcegraph cloud account

Learn about connecting your private code repositories to Sourcegraph cloud and searching your own code.

Search

How to find error messages with Sourcegraph (video)

How to search code with Sourcegraph — a cheat sheet

How to search code with Sourcegraph using literal patterns

Video

How to add open source software to Sourcegraph cloud (video)

How to add private code repositories to Sourcegraph cloud (video)

How to find error messages with Sourcegraph (video)