Standard key/value datastore for unix

The name of the pictureThe name of the pictureThe name of the pictureClash Royale CLAN TAG#URR8PPP





.everyoneloves__top-leaderboard:empty,.everyoneloves__mid-leaderboard:empty,.everyoneloves__bot-mid-leaderboard:empty margin-bottom:0;








16















I know about the key/value libraries for unix (berkeleydb, gdbm, redis... ). But before I start coding, I wonder if there is a standard tool for unix that would allow me to perform the following operations:



$ tool -f datastore.db put "KEY" "VALUE"
$ tool -f datastore.db put -f file_key_values.txt
$ tool -f datastore.db get "KEY"
$ tool -f datastore.db get -f file_keys.txt
$ tool -f datastore.db remove "KEY"
$ etc...


Thanks










share|improve this question




























    16















    I know about the key/value libraries for unix (berkeleydb, gdbm, redis... ). But before I start coding, I wonder if there is a standard tool for unix that would allow me to perform the following operations:



    $ tool -f datastore.db put "KEY" "VALUE"
    $ tool -f datastore.db put -f file_key_values.txt
    $ tool -f datastore.db get "KEY"
    $ tool -f datastore.db get -f file_keys.txt
    $ tool -f datastore.db remove "KEY"
    $ etc...


    Thanks










    share|improve this question
























      16












      16








      16


      5






      I know about the key/value libraries for unix (berkeleydb, gdbm, redis... ). But before I start coding, I wonder if there is a standard tool for unix that would allow me to perform the following operations:



      $ tool -f datastore.db put "KEY" "VALUE"
      $ tool -f datastore.db put -f file_key_values.txt
      $ tool -f datastore.db get "KEY"
      $ tool -f datastore.db get -f file_keys.txt
      $ tool -f datastore.db remove "KEY"
      $ etc...


      Thanks










      share|improve this question














      I know about the key/value libraries for unix (berkeleydb, gdbm, redis... ). But before I start coding, I wonder if there is a standard tool for unix that would allow me to perform the following operations:



      $ tool -f datastore.db put "KEY" "VALUE"
      $ tool -f datastore.db put -f file_key_values.txt
      $ tool -f datastore.db get "KEY"
      $ tool -f datastore.db get -f file_keys.txt
      $ tool -f datastore.db remove "KEY"
      $ etc...


      Thanks







      database






      share|improve this question













      share|improve this question











      share|improve this question




      share|improve this question










      asked Oct 3 '11 at 12:42









      PierrePierre

      6682818




      6682818




















          4 Answers
          4






          active

          oldest

          votes


















          10














          I don't think there is a standard tool for that. Except for grep/awk/sed etc. But using this you will need to care about lot of other issues like locking, format, special characters, etc.



          I suggest to use sqlite. Define a simple table and then create tool_get() and tool_put() shell functions. sqlite is portable, fast.



          You will get extra flexibility for free. You can define constrains, index to tweak your script or use that DB in other languages some day.






          share|improve this answer

























          • Thank you . I quickly wrote a tool with the sqlite API. It works fine.

            – Pierre
            Oct 3 '11 at 21:22


















          8














          If your database is small enough, then you can use the filesystem. The advantage of this approach is that it's very low-tech, and will work everywhere with very little code. If the keys are composed of printable characters and do not contain /, then you can use them as file names:





          put () key=$1; value=$2; printf %s "$value" >"datastore.db/$key"; 
          get () key=$1; cat "datastore.db/$key";
          remove () key=$1; rm "datastore.db/$key";


          To accommodate arbitrary keys, use a checksum of the key as the file name, and optionally store a copy of the key (unless you're happy with not being able to list the keys or tell what the key is for a given entry).



          put () sha1sum); sum=$1
          printf %s "$key" >"datastore.db/$sum.key"
          printf %s "$value" >"datastore.db/$sum.value"

          get ()
          key=$1; set $(printf %s "$key"
          remove () sha1sum); sum=$1
          rm "datastore.db/$1.key" "datastore.db/$1.value"



          Note that the toy implementations above are not the whole story: they do not have any useful transactional property such as atomicity. The basic filesystem operations such as file creation and renaming are atomic however, and it is possible to build atomic versions of the functions above.



          These direct-to-filesystem implementations are suitable with typical filesystems only for small databases, up to a few thousand files. Beyond this point, most filesystems have a hard time coping with large directories. You can adapt the scheme to larger databases by using a layered layout. For example, instead of storing all the files in one directory, store them in separate subdirectories based on the first few characters of their names. This is what git does, for example: its objects, indexed by SHA-1 hashes, are stored in files called .git/objects/01/2345679abcdef0123456789abcdef01234567. Other examples of programs that use a semantic layering are the web caching proxies Wwwoffle and polipo; both store the cached copy of a page found at a URL in a file called www.example.com/HASH where HASH is some encoding of some hash of the URL.¹



          Another source of inefficiency is that most filesystems waste a lot of space when storing small files — there is a waste of up to 2kB per file on typical filesystems, independently of the size of the file.



          If you choose to go with a real database, you don't need to forego the convenience of transparent filesystem access. There are several FUSE filesystems to access databases including Berkeley DB (with Jeff Garzik's dbfs), Oracle (with Oracle DBFS), MySQL (with mysqlfs), etc.



          ¹
          For an URL like http://unix.stackexchange.com/questions/21943/standard-key-value-datastore-for-unix, Polipo uses the file unix.stackexchange.com/M0pPbpRufiErf4DLFcWlhw==, with an added header inside the file indicating the actual URL in clear text; the file name is the base64 encoding of the MD5 hash (in binary) of the URL. Wwwoffle uses the file http/unix.stackexchange.com/DM0pPbpRufiErf4DLFcWlhw; the name of the file is a home-grown encoding of the MD5 hash, and a companion file http/unix.stackexchange.com/UM0pPbpRufiErf4DLFcWlhw contains the URL.






          share|improve this answer
































            7














            dbmutil might get you what you want. It has shell utilities for the operations you describe in the question. I wouldn't say it's exactly standard, but it does have the facilities you want.






            share|improve this answer






























              5














              Since you named it, the standard redis client has a command line interface through redis-cli. Some examples from redis-cli -h:



               cat /etc/passwd | redis-cli -x set mypasswd
              redis-cli get mypasswd
              redis-cli -r 100 lpush mylist x


              (And if you want to access the db through the filesystem you can use sockets with -s. A tool that would read the db index directly on each invocation would be kind of very inefficient.)






              share|improve this answer

























                Your Answer








                StackExchange.ready(function()
                var channelOptions =
                tags: "".split(" "),
                id: "106"
                ;
                initTagRenderer("".split(" "), "".split(" "), channelOptions);

                StackExchange.using("externalEditor", function()
                // Have to fire editor after snippets, if snippets enabled
                if (StackExchange.settings.snippets.snippetsEnabled)
                StackExchange.using("snippets", function()
                createEditor();
                );

                else
                createEditor();

                );

                function createEditor()
                StackExchange.prepareEditor(
                heartbeatType: 'answer',
                autoActivateHeartbeat: false,
                convertImagesToLinks: false,
                noModals: true,
                showLowRepImageUploadWarning: true,
                reputationToPostImages: null,
                bindNavPrevention: true,
                postfix: "",
                imageUploader:
                brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
                contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
                allowUrls: true
                ,
                onDemand: true,
                discardSelector: ".discard-answer"
                ,immediatelyShowMarkdownHelp:true
                );



                );













                draft saved

                draft discarded


















                StackExchange.ready(
                function ()
                StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2funix.stackexchange.com%2fquestions%2f21943%2fstandard-key-value-datastore-for-unix%23new-answer', 'question_page');

                );

                Post as a guest















                Required, but never shown

























                4 Answers
                4






                active

                oldest

                votes








                4 Answers
                4






                active

                oldest

                votes









                active

                oldest

                votes






                active

                oldest

                votes









                10














                I don't think there is a standard tool for that. Except for grep/awk/sed etc. But using this you will need to care about lot of other issues like locking, format, special characters, etc.



                I suggest to use sqlite. Define a simple table and then create tool_get() and tool_put() shell functions. sqlite is portable, fast.



                You will get extra flexibility for free. You can define constrains, index to tweak your script or use that DB in other languages some day.






                share|improve this answer

























                • Thank you . I quickly wrote a tool with the sqlite API. It works fine.

                  – Pierre
                  Oct 3 '11 at 21:22















                10














                I don't think there is a standard tool for that. Except for grep/awk/sed etc. But using this you will need to care about lot of other issues like locking, format, special characters, etc.



                I suggest to use sqlite. Define a simple table and then create tool_get() and tool_put() shell functions. sqlite is portable, fast.



                You will get extra flexibility for free. You can define constrains, index to tweak your script or use that DB in other languages some day.






                share|improve this answer

























                • Thank you . I quickly wrote a tool with the sqlite API. It works fine.

                  – Pierre
                  Oct 3 '11 at 21:22













                10












                10








                10







                I don't think there is a standard tool for that. Except for grep/awk/sed etc. But using this you will need to care about lot of other issues like locking, format, special characters, etc.



                I suggest to use sqlite. Define a simple table and then create tool_get() and tool_put() shell functions. sqlite is portable, fast.



                You will get extra flexibility for free. You can define constrains, index to tweak your script or use that DB in other languages some day.






                share|improve this answer















                I don't think there is a standard tool for that. Except for grep/awk/sed etc. But using this you will need to care about lot of other issues like locking, format, special characters, etc.



                I suggest to use sqlite. Define a simple table and then create tool_get() and tool_put() shell functions. sqlite is portable, fast.



                You will get extra flexibility for free. You can define constrains, index to tweak your script or use that DB in other languages some day.







                share|improve this answer














                share|improve this answer



                share|improve this answer








                edited Oct 3 '11 at 14:43









                enzotib

                34.6k810395




                34.6k810395










                answered Oct 3 '11 at 13:38









                Michał ŠrajerMichał Šrajer

                2,3601116




                2,3601116












                • Thank you . I quickly wrote a tool with the sqlite API. It works fine.

                  – Pierre
                  Oct 3 '11 at 21:22

















                • Thank you . I quickly wrote a tool with the sqlite API. It works fine.

                  – Pierre
                  Oct 3 '11 at 21:22
















                Thank you . I quickly wrote a tool with the sqlite API. It works fine.

                – Pierre
                Oct 3 '11 at 21:22





                Thank you . I quickly wrote a tool with the sqlite API. It works fine.

                – Pierre
                Oct 3 '11 at 21:22













                8














                If your database is small enough, then you can use the filesystem. The advantage of this approach is that it's very low-tech, and will work everywhere with very little code. If the keys are composed of printable characters and do not contain /, then you can use them as file names:





                put () key=$1; value=$2; printf %s "$value" >"datastore.db/$key"; 
                get () key=$1; cat "datastore.db/$key";
                remove () key=$1; rm "datastore.db/$key";


                To accommodate arbitrary keys, use a checksum of the key as the file name, and optionally store a copy of the key (unless you're happy with not being able to list the keys or tell what the key is for a given entry).



                put () sha1sum); sum=$1
                printf %s "$key" >"datastore.db/$sum.key"
                printf %s "$value" >"datastore.db/$sum.value"

                get ()
                key=$1; set $(printf %s "$key"
                remove () sha1sum); sum=$1
                rm "datastore.db/$1.key" "datastore.db/$1.value"



                Note that the toy implementations above are not the whole story: they do not have any useful transactional property such as atomicity. The basic filesystem operations such as file creation and renaming are atomic however, and it is possible to build atomic versions of the functions above.



                These direct-to-filesystem implementations are suitable with typical filesystems only for small databases, up to a few thousand files. Beyond this point, most filesystems have a hard time coping with large directories. You can adapt the scheme to larger databases by using a layered layout. For example, instead of storing all the files in one directory, store them in separate subdirectories based on the first few characters of their names. This is what git does, for example: its objects, indexed by SHA-1 hashes, are stored in files called .git/objects/01/2345679abcdef0123456789abcdef01234567. Other examples of programs that use a semantic layering are the web caching proxies Wwwoffle and polipo; both store the cached copy of a page found at a URL in a file called www.example.com/HASH where HASH is some encoding of some hash of the URL.¹



                Another source of inefficiency is that most filesystems waste a lot of space when storing small files — there is a waste of up to 2kB per file on typical filesystems, independently of the size of the file.



                If you choose to go with a real database, you don't need to forego the convenience of transparent filesystem access. There are several FUSE filesystems to access databases including Berkeley DB (with Jeff Garzik's dbfs), Oracle (with Oracle DBFS), MySQL (with mysqlfs), etc.



                ¹
                For an URL like http://unix.stackexchange.com/questions/21943/standard-key-value-datastore-for-unix, Polipo uses the file unix.stackexchange.com/M0pPbpRufiErf4DLFcWlhw==, with an added header inside the file indicating the actual URL in clear text; the file name is the base64 encoding of the MD5 hash (in binary) of the URL. Wwwoffle uses the file http/unix.stackexchange.com/DM0pPbpRufiErf4DLFcWlhw; the name of the file is a home-grown encoding of the MD5 hash, and a companion file http/unix.stackexchange.com/UM0pPbpRufiErf4DLFcWlhw contains the URL.






                share|improve this answer





























                  8














                  If your database is small enough, then you can use the filesystem. The advantage of this approach is that it's very low-tech, and will work everywhere with very little code. If the keys are composed of printable characters and do not contain /, then you can use them as file names:





                  put () key=$1; value=$2; printf %s "$value" >"datastore.db/$key"; 
                  get () key=$1; cat "datastore.db/$key";
                  remove () key=$1; rm "datastore.db/$key";


                  To accommodate arbitrary keys, use a checksum of the key as the file name, and optionally store a copy of the key (unless you're happy with not being able to list the keys or tell what the key is for a given entry).



                  put () sha1sum); sum=$1
                  printf %s "$key" >"datastore.db/$sum.key"
                  printf %s "$value" >"datastore.db/$sum.value"

                  get ()
                  key=$1; set $(printf %s "$key"
                  remove () sha1sum); sum=$1
                  rm "datastore.db/$1.key" "datastore.db/$1.value"



                  Note that the toy implementations above are not the whole story: they do not have any useful transactional property such as atomicity. The basic filesystem operations such as file creation and renaming are atomic however, and it is possible to build atomic versions of the functions above.



                  These direct-to-filesystem implementations are suitable with typical filesystems only for small databases, up to a few thousand files. Beyond this point, most filesystems have a hard time coping with large directories. You can adapt the scheme to larger databases by using a layered layout. For example, instead of storing all the files in one directory, store them in separate subdirectories based on the first few characters of their names. This is what git does, for example: its objects, indexed by SHA-1 hashes, are stored in files called .git/objects/01/2345679abcdef0123456789abcdef01234567. Other examples of programs that use a semantic layering are the web caching proxies Wwwoffle and polipo; both store the cached copy of a page found at a URL in a file called www.example.com/HASH where HASH is some encoding of some hash of the URL.¹



                  Another source of inefficiency is that most filesystems waste a lot of space when storing small files — there is a waste of up to 2kB per file on typical filesystems, independently of the size of the file.



                  If you choose to go with a real database, you don't need to forego the convenience of transparent filesystem access. There are several FUSE filesystems to access databases including Berkeley DB (with Jeff Garzik's dbfs), Oracle (with Oracle DBFS), MySQL (with mysqlfs), etc.



                  ¹
                  For an URL like http://unix.stackexchange.com/questions/21943/standard-key-value-datastore-for-unix, Polipo uses the file unix.stackexchange.com/M0pPbpRufiErf4DLFcWlhw==, with an added header inside the file indicating the actual URL in clear text; the file name is the base64 encoding of the MD5 hash (in binary) of the URL. Wwwoffle uses the file http/unix.stackexchange.com/DM0pPbpRufiErf4DLFcWlhw; the name of the file is a home-grown encoding of the MD5 hash, and a companion file http/unix.stackexchange.com/UM0pPbpRufiErf4DLFcWlhw contains the URL.






                  share|improve this answer



























                    8












                    8








                    8







                    If your database is small enough, then you can use the filesystem. The advantage of this approach is that it's very low-tech, and will work everywhere with very little code. If the keys are composed of printable characters and do not contain /, then you can use them as file names:





                    put () key=$1; value=$2; printf %s "$value" >"datastore.db/$key"; 
                    get () key=$1; cat "datastore.db/$key";
                    remove () key=$1; rm "datastore.db/$key";


                    To accommodate arbitrary keys, use a checksum of the key as the file name, and optionally store a copy of the key (unless you're happy with not being able to list the keys or tell what the key is for a given entry).



                    put () sha1sum); sum=$1
                    printf %s "$key" >"datastore.db/$sum.key"
                    printf %s "$value" >"datastore.db/$sum.value"

                    get ()
                    key=$1; set $(printf %s "$key"
                    remove () sha1sum); sum=$1
                    rm "datastore.db/$1.key" "datastore.db/$1.value"



                    Note that the toy implementations above are not the whole story: they do not have any useful transactional property such as atomicity. The basic filesystem operations such as file creation and renaming are atomic however, and it is possible to build atomic versions of the functions above.



                    These direct-to-filesystem implementations are suitable with typical filesystems only for small databases, up to a few thousand files. Beyond this point, most filesystems have a hard time coping with large directories. You can adapt the scheme to larger databases by using a layered layout. For example, instead of storing all the files in one directory, store them in separate subdirectories based on the first few characters of their names. This is what git does, for example: its objects, indexed by SHA-1 hashes, are stored in files called .git/objects/01/2345679abcdef0123456789abcdef01234567. Other examples of programs that use a semantic layering are the web caching proxies Wwwoffle and polipo; both store the cached copy of a page found at a URL in a file called www.example.com/HASH where HASH is some encoding of some hash of the URL.¹



                    Another source of inefficiency is that most filesystems waste a lot of space when storing small files — there is a waste of up to 2kB per file on typical filesystems, independently of the size of the file.



                    If you choose to go with a real database, you don't need to forego the convenience of transparent filesystem access. There are several FUSE filesystems to access databases including Berkeley DB (with Jeff Garzik's dbfs), Oracle (with Oracle DBFS), MySQL (with mysqlfs), etc.



                    ¹
                    For an URL like http://unix.stackexchange.com/questions/21943/standard-key-value-datastore-for-unix, Polipo uses the file unix.stackexchange.com/M0pPbpRufiErf4DLFcWlhw==, with an added header inside the file indicating the actual URL in clear text; the file name is the base64 encoding of the MD5 hash (in binary) of the URL. Wwwoffle uses the file http/unix.stackexchange.com/DM0pPbpRufiErf4DLFcWlhw; the name of the file is a home-grown encoding of the MD5 hash, and a companion file http/unix.stackexchange.com/UM0pPbpRufiErf4DLFcWlhw contains the URL.






                    share|improve this answer















                    If your database is small enough, then you can use the filesystem. The advantage of this approach is that it's very low-tech, and will work everywhere with very little code. If the keys are composed of printable characters and do not contain /, then you can use them as file names:





                    put () key=$1; value=$2; printf %s "$value" >"datastore.db/$key"; 
                    get () key=$1; cat "datastore.db/$key";
                    remove () key=$1; rm "datastore.db/$key";


                    To accommodate arbitrary keys, use a checksum of the key as the file name, and optionally store a copy of the key (unless you're happy with not being able to list the keys or tell what the key is for a given entry).



                    put () sha1sum); sum=$1
                    printf %s "$key" >"datastore.db/$sum.key"
                    printf %s "$value" >"datastore.db/$sum.value"

                    get ()
                    key=$1; set $(printf %s "$key"
                    remove () sha1sum); sum=$1
                    rm "datastore.db/$1.key" "datastore.db/$1.value"



                    Note that the toy implementations above are not the whole story: they do not have any useful transactional property such as atomicity. The basic filesystem operations such as file creation and renaming are atomic however, and it is possible to build atomic versions of the functions above.



                    These direct-to-filesystem implementations are suitable with typical filesystems only for small databases, up to a few thousand files. Beyond this point, most filesystems have a hard time coping with large directories. You can adapt the scheme to larger databases by using a layered layout. For example, instead of storing all the files in one directory, store them in separate subdirectories based on the first few characters of their names. This is what git does, for example: its objects, indexed by SHA-1 hashes, are stored in files called .git/objects/01/2345679abcdef0123456789abcdef01234567. Other examples of programs that use a semantic layering are the web caching proxies Wwwoffle and polipo; both store the cached copy of a page found at a URL in a file called www.example.com/HASH where HASH is some encoding of some hash of the URL.¹



                    Another source of inefficiency is that most filesystems waste a lot of space when storing small files — there is a waste of up to 2kB per file on typical filesystems, independently of the size of the file.



                    If you choose to go with a real database, you don't need to forego the convenience of transparent filesystem access. There are several FUSE filesystems to access databases including Berkeley DB (with Jeff Garzik's dbfs), Oracle (with Oracle DBFS), MySQL (with mysqlfs), etc.



                    ¹
                    For an URL like http://unix.stackexchange.com/questions/21943/standard-key-value-datastore-for-unix, Polipo uses the file unix.stackexchange.com/M0pPbpRufiErf4DLFcWlhw==, with an added header inside the file indicating the actual URL in clear text; the file name is the base64 encoding of the MD5 hash (in binary) of the URL. Wwwoffle uses the file http/unix.stackexchange.com/DM0pPbpRufiErf4DLFcWlhw; the name of the file is a home-grown encoding of the MD5 hash, and a companion file http/unix.stackexchange.com/UM0pPbpRufiErf4DLFcWlhw contains the URL.







                    share|improve this answer














                    share|improve this answer



                    share|improve this answer








                    edited Mar 10 at 21:13

























                    answered Oct 3 '11 at 21:55









                    GillesGilles

                    546k12911111625




                    546k12911111625





















                        7














                        dbmutil might get you what you want. It has shell utilities for the operations you describe in the question. I wouldn't say it's exactly standard, but it does have the facilities you want.






                        share|improve this answer



























                          7














                          dbmutil might get you what you want. It has shell utilities for the operations you describe in the question. I wouldn't say it's exactly standard, but it does have the facilities you want.






                          share|improve this answer

























                            7












                            7








                            7







                            dbmutil might get you what you want. It has shell utilities for the operations you describe in the question. I wouldn't say it's exactly standard, but it does have the facilities you want.






                            share|improve this answer













                            dbmutil might get you what you want. It has shell utilities for the operations you describe in the question. I wouldn't say it's exactly standard, but it does have the facilities you want.







                            share|improve this answer












                            share|improve this answer



                            share|improve this answer










                            answered Oct 3 '11 at 13:45









                            ConcernedOfTunbridgeWellsConcernedOfTunbridgeWells

                            1,9701111




                            1,9701111





















                                5














                                Since you named it, the standard redis client has a command line interface through redis-cli. Some examples from redis-cli -h:



                                 cat /etc/passwd | redis-cli -x set mypasswd
                                redis-cli get mypasswd
                                redis-cli -r 100 lpush mylist x


                                (And if you want to access the db through the filesystem you can use sockets with -s. A tool that would read the db index directly on each invocation would be kind of very inefficient.)






                                share|improve this answer





























                                  5














                                  Since you named it, the standard redis client has a command line interface through redis-cli. Some examples from redis-cli -h:



                                   cat /etc/passwd | redis-cli -x set mypasswd
                                  redis-cli get mypasswd
                                  redis-cli -r 100 lpush mylist x


                                  (And if you want to access the db through the filesystem you can use sockets with -s. A tool that would read the db index directly on each invocation would be kind of very inefficient.)






                                  share|improve this answer



























                                    5












                                    5








                                    5







                                    Since you named it, the standard redis client has a command line interface through redis-cli. Some examples from redis-cli -h:



                                     cat /etc/passwd | redis-cli -x set mypasswd
                                    redis-cli get mypasswd
                                    redis-cli -r 100 lpush mylist x


                                    (And if you want to access the db through the filesystem you can use sockets with -s. A tool that would read the db index directly on each invocation would be kind of very inefficient.)






                                    share|improve this answer















                                    Since you named it, the standard redis client has a command line interface through redis-cli. Some examples from redis-cli -h:



                                     cat /etc/passwd | redis-cli -x set mypasswd
                                    redis-cli get mypasswd
                                    redis-cli -r 100 lpush mylist x


                                    (And if you want to access the db through the filesystem you can use sockets with -s. A tool that would read the db index directly on each invocation would be kind of very inefficient.)







                                    share|improve this answer














                                    share|improve this answer



                                    share|improve this answer








                                    edited Oct 3 '11 at 14:17

























                                    answered Oct 3 '11 at 14:08









                                    Stéphane GimenezStéphane Gimenez

                                    19.7k25275




                                    19.7k25275



























                                        draft saved

                                        draft discarded
















































                                        Thanks for contributing an answer to Unix & Linux Stack Exchange!


                                        • Please be sure to answer the question. Provide details and share your research!

                                        But avoid


                                        • Asking for help, clarification, or responding to other answers.

                                        • Making statements based on opinion; back them up with references or personal experience.

                                        To learn more, see our tips on writing great answers.




                                        draft saved


                                        draft discarded














                                        StackExchange.ready(
                                        function ()
                                        StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2funix.stackexchange.com%2fquestions%2f21943%2fstandard-key-value-datastore-for-unix%23new-answer', 'question_page');

                                        );

                                        Post as a guest















                                        Required, but never shown





















































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown

































                                        Required, but never shown














                                        Required, but never shown












                                        Required, but never shown







                                        Required, but never shown






                                        Popular posts from this blog

                                        How to check contact read email or not when send email to Individual?

                                        Displaying single band from multi-band raster using QGIS

                                        How many registers does an x86_64 CPU actually have?