1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
Development Guide
-----------------
This is a guide for developers who would like to contribute to this project.
GitHub Workflow
------------
If you're interested in contributing to pgcli, first of all my heart felt
thanks. `Fork the project <https://github.com/dbcli/pgcli>`_ in github. Then
clone your fork into your computer (``git clone <url-for-your-fork>``). Make
the changes and create the commits in your local machine. Then push those
changes to your fork. Then click on the pull request icon on github and create
a new pull request. Add a description about the change and send it along. I
promise to review the pull request in a reasonable window of time and get back
to you.
In order to keep your fork up to date with any changes from mainline, add a new
git remote to your local copy called 'upstream' and point it to the main pgcli
repo.
::
$ git remote add upstream git@github.com:dbcli/pgcli.git
Once the 'upstream' end point is added you can then periodically do a ``git
pull upstream master`` to update your local copy and then do a ``git push
origin master`` to keep your own fork up to date.
Local Setup
-----------
The installation instructions in the README file are intended for users of
pgcli. If you're developing pgcli, you'll need to install it in a slightly
different way so you can see the effects of your changes right away without
having to go through the install cycle everytime you change the code.
It is highly recommended to use virtualenv for development. If you don't know
what a virtualenv is, this `guide <http://docs.python-guide.org/en/latest/dev/virtualenvs/#virtual-environments>`_
will help you get started.
Create a virtualenv (let's call it pgcli-dev). Activate it:
::
source ./pgcli-dev/bin/activate
Once the virtualenv is activated, `cd` into the local clone of pgcli folder
and install pgcli using pip as follows:
::
$ pip install --editable .
or
$ pip install -e .
This will install the necessary dependencies as well as install pgcli from the
working folder into the virtualenv. By installing it using `pip install -e`
we've linked the pgcli installation with the working copy. So any changes made
to the code is immediately available in the installed version of pgcli. This
makes it easy to change something in the code, launch pgcli and check the
effects of your change.
Adding PostgreSQL Special (Meta) Commands
-----------------------------------------
If you want to work on adding new meta-commands (such as `\dp`, `\ds`, `dy`),
you'll be changing the code of `packages/pgspecial.py`. Search for the
dictionary called `CASE_SENSITIVE_COMMANDS`. The special command us used as
the dictionary key, and the value is a tuple.
The first item in the tuple is either a string (sql statement) or a function.
The second item in the tuple is a list of strings which is the documentation
for that special command. The list will have two items, the first item is the
command itself with possible options and the second item is the plain english
description of that command.
For example, `\l` is a meta-command that lists all the databases. The way you
can see the SQL statement issued by PostgreSQL when this command is executed
is to launch `psql -E` and entering `\l`.
That will print the results and also print the sql statement that was executed
to produce that result. In most cases it's a single sql statement, but sometimes
it's a series of sql statements that feed the results to each other to get to
the final result.
Building RPM and DEB packages
-----------------------------
You will need Vagrant 1.7.2 or higher. In the project root there is a
Vagrantfile that is setup to do multi-vm provisioning. If you're setting things
up for the first time, then do:
::
$ version=x.y.z vagrant up debian
$ version=x.y.z vagrant up centos
If you already have those VMs setup and you're merely creating a new version of
DEB or RPM package, then you can do:
::
$ version=x.y.z vagrant provision
That will create a .deb file and a .rpm file.
The deb package can be installed as follows:
::
$ sudo dpkg -i pgcli*.deb # if dependencies are available.
or
$ sudo apt-get install -f pgcli*.deb # if dependencies are not available.
The rpm package can be installed as follows:
::
$ sudo yum install pgcli*.rpm
Running the integration tests
-----------------------------
Integration tests use `behave package http://pythonhosted.org/behave/`_.
Configuration settings for this package are provided via ``behave.ini`` file
in root directory.
The database user (``pg_test_user = postgres`` in .ini file) has to have
permissions to create and drop test database. Dafault user is ``postgres``
at ``localhost``, without the password (authentication mode trust).
First, install the requirements for testing:
::
$ pip install -r requirements-dev.txt
After that, tests can be run with:
::
$ behave
To see stdout/stderr, use the following command:
::
$ behave --no-capture
|
